Dart 3.13 / Flutter 3.47.6 : SDK à jour et épinglé partout

L'image ghcr.io/cirruslabs/flutter:stable n'est plus publiée depuis
Flutter 3.44.0 : le build Docker compilait toujours avec Dart 3.12.0
(mai 2026), alors que la CI testait le serveur en Dart 3.13 et le
front en Flutter 3.38.4. Trois SDK différents selon l'endroit.

- Dockerfile : SDK Flutter officiel 3.47.6 (Dart 3.13.5) téléchargé
  depuis flutter_infra_release, version en ARG
- CI : Flutter 3.38.4 → 3.47.6, Dart 3.13.2 → 3.13.5 — même SDK que
  l'image
- pubspec : contrainte sdk ^3.13.0 (au lieu de >=3.0.0) pour pouvoir
  utiliser les nouveautés du langage (constructeurs primaires,
  raccourcis `.valeur`, éléments `?x`). Les lockfiles exigeaient déjà
  3.10.3 / 3.11.0 : le minimum affiché était faux

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

.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
           # fil du temps (une release Flutter peut casser la CI sans aucun
           # changement dans le dépôt). Le cache évite de retélécharger SDK et
           # dépendances pub à chaque run.
-          flutter-version: 3.38.4
+          flutter-version: 3.47.6
           channel: stable
           cache: true
       - run: flutter pub get
@@ -42,7 +42,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dart-lang/setup-dart@v1
         with:
-          sdk: 3.13.2
+          sdk: 3.13.5
       - run: dart pub get
       - run: dart analyze
       - run: dart test

CHANGELOG.md

@@ -2,11 +2,31 @@
 
 ## Non publié
 
+### 🖼️ Logos des chaînes
+- **Logos de repli quand l'hébergeur de picons tombe** : nouvelle route `/api/logo?src=…&name=…`. L'URL du panneau est tentée d'abord (via le proxy, mêmes protections anti-SSRF) ; en cas d'échec, le logo est cherché par nom de chaîne dans le dépôt public [`tv-logo/tv-logos`](https://github.com/tv-logo/tv-logos) — préfixe pays et suffixes de qualité ignorés, `Canal+` → `canal-plus`, repli sur la marque pour les canaux événementiels (`RMC SPORT LIVE 5` → logo RMC Sport). La liste des logos est mise en cache 24 h (l'API GitHub non authentifiée plafonne à 60 requêtes/h), les images en mémoire. Les chaînes sans `stream_icon` y gagnent aussi un logo
+- **Plus d'acharnement sur un hébergeur de picons hors service** : une image en erreur n'est plus relayée telle quelle au navigateur, qui la redemandait à chaque affichage de la grille. Réponse 410 mise en cache dix minutes (410 et non 404 : la `Cascade` du serveur rattrape les 404 et perdait l'en-tête de cache) ; au bout de trois échecs consécutifs, l'hôte est considéré hors service cinq minutes et plus aucune requête ne sort. Un statut d'erreur plutôt qu'un pixel transparent : le client affiche son propre repli au lieu d'une tuile vide
+- **Logos de l'onglet Enregistrements** : l'URL `http://` du panneau y était chargée directement, bloquée par le navigateur sur une page servie en HTTPS
+
+### 📺 Guide TV (EPG)
+- **Guide servi par le dump `xmltv.php` du panneau** : `player_api` réclamait un appel par chaîne, à plusieurs secondes pièce chez la plupart des revendeurs — une grille de trente chaînes mettait plus d'une minute à se remplir. Le dump du panneau couvre toutes les chaînes en une requête, réutilisée trois heures. L'interrogation chaîne par chaîne reste le repli quand le dump est absent ou ne couvre pas la chaîne, suivie de la source XMLTV externe
+- **Une source XMLTV morte n'est plus retéléchargée à chaque consultation** : après un échec, la source est laissée de côté quinze minutes
+- **Index XMLTV borné à 48 h** : un dump national couvre sept jours pour un millier de chaînes ; tout garder coûtait des centaines de mégaoctets au conteneur pour un guide qui n'affiche que le programme courant et les suivants
+
 ### ▶️ Lecture vidéo
+- **Fix du démarrage des enregistrements** : la lecture partait au milieu du programme et se coupait aussitôt, obligeant à relancer une deuxième fois. Une playlist encore en cours de transcodage n'a pas d'`EXT-X-ENDLIST` : hls.js la traite comme du direct et démarrait donc au « bord du direct », collé au front d'encodage, sans aucune avance de segments. `startPosition: 0` hors direct, plus la neutralisation du rattrapage de latence (qui accélérait la lecture puis forçait un saut en avant pour rejoindre un direct inexistant)
+- **Plus de ré-encodage inutile à la lecture d'un enregistrement** : la capture étant faite en copie, le fichier contient déjà du H.264 dans la quasi-totalité des cas. Il est désormais servi tel quel (`-c:v copy`, seul l'audio est converti en AAC) au lieu d'être ré-encodé à peine plus vite que le temps réel — la segmentation va maintenant à la vitesse du disque, l'enregistrement devient navigable en quelques secondes. Les codecs illisibles par le navigateur (HEVC, MPEG-2…) restent ré-encodés
+- **Démarrage plus robuste** : le serveur attend trois segments d'avance avant de servir la playlist (au lieu d'un seul, qui laissait le lecteur courir après l'encodeur), et sert ce qu'il a plutôt qu'une erreur si le délai expire. Côté navigateur, le délai d'attente de playlist passe de 10 s à 45 s hors direct — une session FFmpeg qui démarre n'est plus prise pour un manifeste mort — et le lecteur de bureau réessaie seul jusqu'à 3 fois, comme le faisait déjà le lecteur mobile
+- **Lecteur avancé pour les enregistrements** : barre de progression réellement utilisable (avance, retour, saut n'importe où), pause/reprise, et reprise automatique là où on s'était arrêté. La playlist d'un enregistrement était servie en `EXT-X-PLAYLIST-TYPE:VOD` : hls.js la considérait comme définitive et ne voyait donc que les quelques secondes déjà transcodées à l'ouverture. Elle passe en `EVENT` (la zone navigable grandit avec l'encodage) et un saut hors de cette zone relance FFmpeg à la position visée (`?start=`), au lieu d'attendre que l'encodeur y arrive
+- **Reprise des enregistrements** : la liste affiche « Reprendre à … » avec la progression, et propose au clic de reprendre ou de repartir du début ; la durée affichée est mesurée par ffprobe (`duration_seconds`) et non plus déduite des horaires programmés — un enregistrement arrêté en avance donnait une barre fausse
+- **Contrôles enrichis (VOD, séries, enregistrements)** : sauts ±10 s et ±1 min, sélecteur de vitesse (0,5× à 2×), portion déjà transcodée visible sur la barre, et raccourcis clavier `K`/espace, `J`/`L`, Maj+←/→, `0`-`9`, `F`, `M`, `,`/`.`
 - **Fix du son manquant sur certaines chaînes** : nouvelle route `/api/live/<id>/turbo.ts` pour le zapping — vidéo copiée telle quelle, audio systématiquement réencodé en AAC côté serveur. Les chaînes en AC-3/E-AC-3/MP2 (que mpegts.js ne décode pas) ont maintenant du son, sans coût de transcodage vidéo
 - **Players mis à jour** : hls.js 1.6.7 → 1.7.1, mpegts.js 1.7.3 → 1.8.2 (vendorisés)
 - **Démarrage plus rapide** : sonde FFmpeg bornée (`-fflags nobuffer`, probesize réduit) sur le live et le turbo ; probesize VOD 10 Mo → 5 Mo ; preset live `high` et lecture d'enregistrement en `veryfast` (medium ne tenait pas le temps réel) ; détection de playlist toutes les 100 ms au lieu de 500 ms ; suppression du cache-buster qui re-téléchargeait player.html à chaque zap (les .html passent en no-cache serveur)
 - **Latence live maîtrisée** : rattrapage du direct activé dans mpegts.js (profil rapide) — les micro-coupures ne font plus dériver la lecture derrière le direct
+- **Fix « Échec du chargement : vendor/mpegts.min.js »** : un échec de chargement d'une lib de lecture n'affiche plus un écran d'erreur définitif. Le chargement est retenté une fois en contournant le cache HTTP (une entrée tronquée condamnait le lecteur jusqu'au vidage manuel du cache), le résultat n'est mémorisé qu'en cas de succès (une promesse rejetée en cache rendait tout réessai impossible) et, si la lib reste introuvable, le live bascule automatiquement sur la route HLS équivalente. Le message affiché précise désormais la cause (HTTP 404, 429, réseau injoignable)
+- **Préchargement de la bonne lib** : les trois players préchargeaient hls.js en dur, soit 618 Ko téléchargés pour rien à chaque zap TV — où c'est mpegts.js qui sert — au détriment du flux et du chargement de mpegts.js. Le préchargement suit maintenant le flux réellement demandé (et ne charge rien sur Safari/iOS, qui lit le HLS nativement)
+- **Contre-pression sur le flux turbo** : le relais de FFmpeg vers le navigateur ne transmettait pas la pause du client à la source. Un lecteur plus lent que le flux — réseau domestique, onglet en arrière-plan — laissait FFmpeg produire à pleine vitesse pendant que le serveur empilait les paquets en mémoire : la lecture dérivait derrière le direct et saccadait
+- **Alerte au démarrage** : le serveur signale explicitement l'absence de `web/vendor/*.min.js` au lancement, au lieu de laisser le navigateur échouer sans explication
 
 ### 🧰 Qualité / Infra
 - **Builds reproductibles** : `pubspec.lock` (frontend et backend) désormais versionnés et utilisés par le Dockerfile — chaque build résolvait jusqu'ici des versions fraîches

Dockerfile

@@ -1,7 +1,26 @@
 # Stage 1: Build Environment (Optimized for Docker Caching)
-FROM ghcr.io/cirruslabs/flutter:stable AS builder
+# SDK Flutter officiel, version épinglée — la même que la CI. L'image
+# ghcr.io/cirruslabs/flutter:stable n'est plus mise à jour : elle était
+# restée sur Flutter 3.44.0 / Dart 3.12.0 (mai 2026), loin derrière la
+# version stable réelle.
+FROM debian:stable-slim AS builder
+
+ARG FLUTTER_VERSION=3.47.6
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    git \
+    unzip \
+    xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -fsSL "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_${FLUTTER_VERSION}-stable.tar.xz" \
+    | tar -xJ -C /opt \
+    && git config --global --add safe.directory /opt/flutter
+
+ENV PATH="/opt/flutter/bin:/opt/flutter/bin/cache/dart-sdk/bin:${PATH}"
 
-USER root
 WORKDIR /app
 
 # Optimize DART VM Memory

bin/api/asset_failure_cache.dart

@@ -0,0 +1,81 @@
+import 'package:shelf/shelf.dart';
+
+/// Réponse pour une image indisponible.
+///
+/// Statut 410 et non 404 : la `Cascade` du serveur retombe sur le handler
+/// suivant pour tout 404 et renvoie finalement celui du handler statique, sans
+/// notre `cache-control`. Un 410 s'arrête ici.
+///
+/// Un statut d'erreur plutôt qu'une image vide : le client affiche alors son
+/// propre repli (icône, initiale) au lieu d'une tuile blanche. 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 aussitôt.
+Response missingImageResponse() => Response(
+      410,
+      headers: {
+        'cache-control': 'public, max-age=600',
+        'access-control-allow-origin': '*',
+      },
+    );
+
+/// Mémoire courte des hôtes d'images injoignables.
+///
+/// POURQUOI : les URL de picons pointent chez l'hébergeur du revendeur, pas
+/// sur le panneau. Quand cette machine tombe (maintenance, DNS, quota), elle
+/// répond 5xx en quelques millisecondes, le navigateur réessaie à chaque
+/// rendu de la grille et le proxy relaie des centaines de requêtes mortes par
+/// seconde. Le serveur tournant sur un unique isolate Dart, ce flot passe
+/// devant les paquets vidéo dans la boucle d'événements : l'image saccade
+/// pendant qu'on s'acharne sur un hôte qu'on sait hors service.
+///
+/// On coupe donc court : au bout de [threshold] échecs consécutifs, l'hôte
+/// est considéré mort pendant [ttl] et les requêtes suivantes sont servies
+/// localement, sans appel sortant.
+class AssetFailureCache {
+  AssetFailureCache({
+    this.threshold = 3,
+    this.ttl = const Duration(minutes: 5),
+    DateTime Function()? clock,
+  }) : _clock = clock ?? DateTime.now;
+
+  /// Nombre d'échecs consécutifs avant de couper un hôte. Un 5xx passager ne
+  /// doit pas priver l'utilisateur de ses logos.
+  final int threshold;
+
+  /// Durée de la coupure. Assez courte pour qu'un hôte réparé revienne seul.
+  final Duration ttl;
+
+  final DateTime Function() _clock;
+
+  final Map<String, int> _failures = {};
+  final Map<String, DateTime> _downUntil = {};
+
+  /// L'hôte est-il réputé hors service en ce moment ?
+  bool isDown(String host) {
+    final key = host.toLowerCase();
+    final until = _downUntil[key];
+    if (until == null) return false;
+    if (_clock().isBefore(until)) return true;
+
+    // Coupure expirée : on repart d'une ardoise vierge pour laisser une
+    // vraie chance au prochain appel.
+    _downUntil.remove(key);
+    _failures.remove(key);
+    return false;
+  }
+
+  void recordFailure(String host) {
+    final key = host.toLowerCase();
+    final count = (_failures[key] ?? 0) + 1;
+    _failures[key] = count;
+    if (count >= threshold) {
+      _downUntil[key] = _clock().add(ttl);
+    }
+  }
+
+  void recordSuccess(String host) {
+    final key = host.toLowerCase();
+    _failures.remove(key);
+    _downUntil.remove(key);
+  }
+}

bin/api/epg_api.dart

@@ -8,10 +8,12 @@ import '../utils/log_redactor.dart';
 /// API EPG — proxy vers Xtream avec cache 30 minutes
 /// GET /api/epg/<channel_id>?days=1
 ///
-/// Le panneau de l'abonné reste la source de référence. Une source XMLTV
-/// externe n'est interrogée qu'en dernier recours, quand le panneau ne rend
-/// aucun programme couvrant l'instant présent ou à venir — cas fréquent des
-/// revendeurs dont le guide est figé depuis plusieurs jours.
+/// Le panneau de l'abonné reste la source de référence, mais par son dump
+/// `xmltv.php` d'abord : une requête couvre toutes les chaînes, là où
+/// `player_api` en réclame une par chaîne à plusieurs secondes pièce. Vient
+/// ensuite l'interrogation chaîne par chaîne, puis une source XMLTV externe
+/// en dernier recours — cas des revendeurs dont le guide est figé depuis
+/// plusieurs jours.
 class EpgApi {
   final Future<PlaylistConfig?> Function(Request) _getPlaylist;
 
@@ -31,7 +33,43 @@ class EpgApi {
   /// pas par `stream_id` propre au panneau.
   final Map<String, _ChannelMap> _channelMaps = {};
 
-  EpgApi(this._getPlaylist, {XmltvEpgService? xmltv}) : _xmltv = xmltv;
+  /// Client HTTP des appels `player_api`. Injectable pour les tests.
+  final http.Client _http;
+
+  /// Fabrique de la source XMLTV du panneau, une par compte.
+  final XmltvEpgService Function(PlaylistConfig) _panelXmltvBuilder;
+
+  /// Index XMLTV du panneau, par compte.
+  final Map<String, XmltvEpgService> _panelXmltv = {};
+
+  EpgApi(
+    this._getPlaylist, {
+    XmltvEpgService? xmltv,
+    http.Client? httpClient,
+    XmltvEpgService Function(PlaylistConfig)? panelXmltvBuilder,
+  })  : _xmltv = xmltv,
+        _http = httpClient ?? http.Client(),
+        _panelXmltvBuilder = panelXmltvBuilder ?? _defaultPanelXmltv;
+
+  /// Dump XMLTV servi par le panneau lui-même.
+  ///
+  /// POURQUOI : `player_api.php?action=get_simple_data_table` répond en
+  /// plusieurs secondes chez beaucoup de revendeurs, et il faut un appel par
+  /// chaîne — afficher une grille de trente chaînes demandait donc plus d'une
+  /// minute. `xmltv.php` renvoie le guide de toutes les chaînes en une seule
+  /// requête, réutilisée ensuite pendant des heures. C'est ce que font les
+  /// clients IPTV rapides.
+  static XmltvEpgService _defaultPanelXmltv(PlaylistConfig playlist) {
+    final user = Uri.encodeQueryComponent(playlist.username);
+    final password = Uri.encodeQueryComponent(playlist.password);
+    return XmltvEpgService(
+      sourceUrls: ['${playlist.dns}/xmltv.php?username=$user&password=$password'],
+      refreshInterval: const Duration(hours: 3),
+      // Le guide est facultatif : on ne fait pas patienter l'utilisateur
+      // plusieurs minutes sur un panneau qui traîne.
+      downloadTimeout: const Duration(seconds: 90),
+    );
+  }
 
   Future<Response> handleGetEpg(Request request, String channelId) async {
     final playlist = await _getPlaylist(request);
@@ -52,47 +90,44 @@ class EpgApi {
     }
 
     try {
-      final dns = playlist.dns;
-      Map<String, dynamic> epgData = {
-        'channel_id': channelId,
-        'programmes': [],
-      };
-
-      // Ordre d'essai des actions Xtream.
+      // Sources par ordre de préférence. On s'arrête à la première qui
+      // contient un programme en cours ou à venir ; à défaut, la première
+      // non vide sert de repli.
       //
-      // `get_simple_data_table` d'abord : c'est la seule action réellement
-      // universelle. `get_epg` n'existe pas sur beaucoup de panneaux — au lieu
-      // d'une erreur, ils renvoient poliment le payload d'authentification,
-      // sans champ `epg_listings`, ce qui produisait un guide vide impossible
-      // à distinguer d'une chaîne sans programme.
-      const actions = [
-        'get_simple_data_table',
-        'get_short_epg',
+      // 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.
+      final sources = <(String, Future<List<Map<String, dynamic>>> Function())>[
+        ('panel-xmltv', () => _panelProgrammes(playlist, channelId)),
+        ('xtream', () => _xtreamProgrammes(playlist, channelId)),
+        ('xmltv', () => _xmltvProgrammes(playlist, channelId)),
       ];
 
-      for (final action in actions) {
-        final url =
-            '$dns/player_api.php?username=${playlist.username}&password=${playlist.password}'
-            '&action=$action&stream_id=$channelId';
-
-        final response =
-            await http.get(Uri.parse(url)).timeout(const Duration(seconds: 60));
-        if (response.statusCode != 200) continue;
-
-        try {
-          epgData = transformEpgData(json.decode(response.body), channelId);
-        } catch (_) {
-          continue;
-        }
-        if ((epgData['programmes'] as List).isNotEmpty) break;
-      }
-
+      var epgData = <String, dynamic>{
+        'channel_id': channelId,
+        'programmes': <Map<String, dynamic>>[],
+      };
       var source = 'xtream';
-      if (!_hasCurrentProgramme(epgData)) {
-        final fallback = await _xmltvProgrammes(playlist, channelId);
-        if (fallback.isNotEmpty) {
-          epgData = {'channel_id': channelId, 'programmes': fallback};
-          source = 'xmltv';
+      var found = false;
+
+      for (final (name, fetch) in sources) {
+        final programmes = await fetch();
+        if (programmes.isEmpty) continue;
+
+        final candidate = <String, dynamic>{
+          'channel_id': channelId,
+          'programmes': programmes,
+        };
+        if (!found) {
+          // Meilleur repli connu à ce stade, même si le guide est périmé.
+          epgData = candidate;
+          source = name;
+          found = true;
+        }
+        if (_hasCurrentProgramme(candidate)) {
+          epgData = candidate;
+          source = name;
+          break;
         }
       }
 
@@ -123,6 +158,57 @@ class EpgApi {
     }
   }
 
+  /// Programmes tirés du dump XMLTV du panneau, ou liste vide.
+  Future<List<Map<String, dynamic>>> _panelProgrammes(
+    PlaylistConfig playlist,
+    String channelId,
+  ) async {
+    final key = '${playlist.dns}|${playlist.username}';
+    final service =
+        _panelXmltv.putIfAbsent(key, () => _panelXmltvBuilder(playlist));
+    return _fromXmltv(service, playlist, channelId);
+  }
+
+  /// Programmes obtenus en interrogeant le panneau chaîne par chaîne.
+  ///
+  /// Chemin lent : deux actions possibles, plusieurs secondes chacune chez la
+  /// plupart des revendeurs. Il ne sert que lorsque le dump XMLTV du panneau
+  /// est absent ou ne couvre pas la chaîne.
+  Future<List<Map<String, dynamic>>> _xtreamProgrammes(
+    PlaylistConfig playlist,
+    String channelId,
+  ) async {
+    // `get_simple_data_table` d'abord : c'est la seule action réellement
+    // universelle. `get_epg` n'existe pas sur beaucoup de panneaux — au lieu
+    // d'une erreur, ils renvoient poliment le payload d'authentification,
+    // sans champ `epg_listings`, ce qui produisait un guide vide impossible
+    // à distinguer d'une chaîne sans programme.
+    const actions = ['get_simple_data_table', 'get_short_epg'];
+
+    for (final action in actions) {
+      final url =
+          '${playlist.dns}/player_api.php?username=${playlist.username}'
+          '&password=${playlist.password}'
+          '&action=$action&stream_id=$channelId';
+
+      final response =
+          await _http.get(Uri.parse(url)).timeout(const Duration(seconds: 60));
+      if (response.statusCode != 200) continue;
+
+      Map<String, dynamic> parsed;
+      try {
+        parsed = transformEpgData(json.decode(response.body), channelId);
+      } catch (_) {
+        continue;
+      }
+      final programmes = (parsed['programmes'] as List)
+          .whereType<Map<String, dynamic>>()
+          .toList();
+      if (programmes.isNotEmpty) return programmes;
+    }
+    return const [];
+  }
+
   /// Le guide contient-il un programme en cours ou à venir ?
   ///
   /// Un panneau dont l'EPG est figé répond avec des centaines de programmes,
@@ -142,8 +228,16 @@ class EpgApi {
   Future<List<Map<String, dynamic>>> _xmltvProgrammes(
     PlaylistConfig playlist,
     String channelId,
+  ) =>
+      _fromXmltv(_xmltv, playlist, channelId);
+
+  /// Programmes d'une chaîne dans un index XMLTV quelconque (panneau ou
+  /// source externe), ou liste vide si l'index ne la connaît pas.
+  Future<List<Map<String, dynamic>>> _fromXmltv(
+    XmltvEpgService? xmltv,
+    PlaylistConfig playlist,
+    String channelId,
   ) async {
-    final xmltv = _xmltv;
     if (xmltv == null) return const [];
 
     try {
@@ -163,7 +257,7 @@ class EpgApi {
           .map((p) => p.toJson(channelId))
           .toList();
     } catch (e) {
-      print('[EpgApi] repli XMLTV indisponible pour $channelId : $e');
+      print('[EpgApi] source XMLTV indisponible pour $channelId : $e');
       return const [];
     }
   }
@@ -180,7 +274,7 @@ class EpgApi {
         '?username=${playlist.username}&password=${playlist.password}'
         '&action=get_live_streams';
     final response =
-        await http.get(Uri.parse(url)).timeout(const Duration(seconds: 90));
+        await _http.get(Uri.parse(url)).timeout(const Duration(seconds: 90));
 
     final epgIds = <String, String>{};
     final names = <String, String>{};

bin/api/logo_api.dart

@@ -0,0 +1,72 @@
+import 'package:shelf/shelf.dart';
+
+import '../services/logo_catalog.dart';
+import 'asset_failure_cache.dart';
+
+/// GET /api/logo?src=<stream_icon>&name=<nom de chaîne>
+///
+/// Logo d'une chaîne, avec repli. L'URL fournie par le panneau est tentée
+/// d'abord, via le proxy Xtream (mêmes protections anti-SSRF, même mémoire
+/// des hôtes morts). En cas d'échec, le logo est cherché par nom dans le
+/// dépôt public `tv-logos`.
+///
+/// POURQUOI : quand l'hébergeur de picons du revendeur tombe, toute la grille
+/// perd ses logos d'un coup, alors que les autres applications IPTV les
+/// affichent encore grâce à leurs propres sources de repli.
+class LogoApi {
+  LogoApi(this._proxy, this._catalog);
+
+  /// Proxy Xtream (`ProxyHandler.handler`), qui attend `/api/xtream/<url>`.
+  final Handler _proxy;
+
+  final LogoCatalog _catalog;
+
+  /// Un logo trouvé change rarement : un jour de cache navigateur.
+  static const _found = 'public, max-age=86400';
+
+  Future<Response> handle(Request request) async {
+    final src = request.url.queryParameters['src'] ?? '';
+    final name = request.url.queryParameters['name'] ?? '';
+
+    // Une URL panneau malformée ne doit pas priver la chaîne du repli.
+    final proxied = src.startsWith('http://') || src.startsWith('https://')
+        ? Uri.tryParse('${request.requestedUri.origin}/api/xtream/$src')
+        : null;
+
+    if (proxied != null) {
+      final upstream = await _proxy(
+        Request(
+          'GET',
+          proxied,
+          headers: {
+            for (final header in const ['cookie', 'authorization'])
+              if (request.headers[header] != null)
+                header: request.headers[header]!,
+          },
+        ),
+      );
+
+      final type = upstream.headers['content-type'] ?? '';
+      if (upstream.statusCode == 200 && type.startsWith('image/')) {
+        return Response.ok(
+          upstream.read(),
+          headers: {'content-type': type, 'cache-control': _found},
+        );
+      }
+      // Corps d'erreur consommé : sinon la connexion amont reste ouverte.
+      await upstream.read().drain<void>();
+    }
+
+    if (name.isNotEmpty) {
+      final bytes = await _catalog.logoFor(name);
+      if (bytes != null) {
+        return Response.ok(
+          bytes,
+          headers: {'content-type': 'image/png', 'cache-control': _found},
+        );
+      }
+    }
+
+    return missingImageResponse();
+  }
+}

bin/api/proxy_handler.dart

@@ -7,6 +7,22 @@ import '../database/database.dart';
 import '../middleware/auth_middleware.dart';
 import '../models/playlist_config.dart';
 import '../utils/log_redactor.dart';
+import 'asset_failure_cache.dart';
+
+/// 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/');
 
 /// Returns true when [host] must never be proxied (loopback, private LAN,
 /// link-local/cloud-metadata ranges) — SSRF protection for asset URLs that
@@ -39,6 +55,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 +160,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 répond 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 missingImageResponse();
+        }
 
         String? allowedHost;
         if (!isStaticAsset) {
@@ -251,6 +270,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 répond un 404 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 missingImageResponse();
+            }
+            _assetFailures.recordSuccess(targetUrl.host);
+          }
+
           // Build response headers from source response
           final responseHeaders = <String, String>{
             'access-control-allow-origin': '*',
@@ -282,15 +318,10 @@ class ProxyHandler {
           '${LogRedactor.redactUrl('$e')}',
         );
 
-        // 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'},
-          );
+        // Image injoignable : 404 mis en cache plutôt qu'une erreur 500
+        if (targetUrl != null && _isStaticAssetUrl(targetUrl)) {
+          _assetFailures.recordFailure(targetUrl.host);
+          return missingImageResponse();
         }
 
         return Response.internalServerError(

bin/api/recording_playlist.dart

@@ -0,0 +1,43 @@
+/// Adressage des sessions de lecture d'un enregistrement.
+///
+/// Un enregistrement est transcodé à la volée par FFmpeg, séquentiellement.
+/// Reprendre à 45 min sans le lui dire imposerait d'attendre que l'encodeur
+/// y arrive : le lecteur demande donc une playlist qui *commence* à cette
+/// position (`?start=2700`), servie par une session FFmpeg dédiée.
+///
+/// Ces fonctions sont isolées du handler HTTP pour rester testables.
+library;
+
+/// Position de départ demandée (`?start=<secondes>`), bornée au positif.
+/// Toute valeur absente, négative ou non numérique vaut « depuis le début ».
+int parseRecordingStart(String? raw) {
+  final value = double.tryParse(raw ?? '');
+  if (value == null || !value.isFinite || value <= 0) return 0;
+  return value.floor();
+}
+
+/// Segment de chemin qui rattache un segment `.ts` à SA session.
+///
+/// Les segments sont référencés en relatif dans la playlist et la
+/// query string n'y survit pas : sans ce répertoire virtuel, la playlist
+/// démarrée à 0 s et celle démarrée à 45 min demanderaient toutes deux
+/// `segment_000.ts` à la même URL.
+String recordingOffsetKey(int start) => 't$start';
+
+/// Inverse de [recordingOffsetKey] ; `null` si la clé est mal formée.
+int? parseRecordingOffsetKey(String key) {
+  if (!key.startsWith('t') || key.length < 2) return null;
+  final value = int.tryParse(key.substring(1));
+  return (value == null || value < 0) ? null : value;
+}
+
+/// Préfixe les segments de [playlist] par [offsetKey].
+///
+/// Seules les lignes de segment sont touchées : les balises `#EXT-X-…` et
+/// les lignes vides passent telles quelles.
+String rewriteRecordingPlaylist(String playlist, String offsetKey) {
+  return playlist.replaceAllMapped(
+    RegExp(r'^(segment_\d+\.ts)\s*$', multiLine: true),
+    (m) => '$offsetKey/${m[1]}',
+  );
+}

bin/api/recordings_api.dart

@@ -6,6 +6,7 @@ import '../database/database.dart';
 import '../models/recording.dart';
 import '../models/user.dart';
 import '../services/recording_scheduler.dart';
+import '../utils/media_probe.dart';
 import '../utils/safe_path.dart';
 
 class RecordingsApi {
@@ -74,18 +75,47 @@ class RecordingsApi {
   /// GET /api/recordings — Liste les enregistrements de l'utilisateur
   /// (tous les enregistrements pour un admin), enrichis des informations de
   /// suivi : taille du fichier, progression, relances FFmpeg.
-  Response handleGetAll(Request request) {
+  Future<Response> handleGetAll(Request request) async {
     final user = request.context['user'] as User?;
     final recordings = (user != null && !user.isAdmin)
         ? _db.getUserRecordings(user.id)
         : _db.getAllRecordings();
     final now = DateTime.now().toUtc();
+    final enriched = <Map<String, dynamic>>[];
+    for (final r in recordings) {
+      final map = _enrich(r, now);
+      // Durée réelle du média : `end_time - start_time` n'est que la durée
+      // *programmée*. Un enregistrement arrêté en avance ou tronqué par une
+      // coupure amont donnait une barre de progression fausse et un « reprendre »
+      // hors des clous.
+      final duration = await _probeDuration(r);
+      if (duration != null) map['duration_seconds'] = duration;
+      enriched.add(map);
+    }
     return Response.ok(
-      json.encode(recordings.map((r) => _enrich(r, now)).toList()),
+      json.encode(enriched),
       headers: {'Content-Type': 'application/json'},
     );
   }
 
+  /// Durée du média en secondes, ou `null` si elle n'est pas mesurable.
+  ///
+  /// Un enregistrement en cours grossit en permanence : le cache de
+  /// [MediaProbe] serait invalidé à chaque appel et ffprobe tournerait en
+  /// boucle. La durée programmée suffit tant que la capture n'est pas
+  /// terminée.
+  Future<double?> _probeDuration(Recording r) async {
+    final path = r.filePath;
+    if (path == null || r.status != 'completed') return null;
+
+    // Anti path-traversal : la mesure doit rester dans le dossier des
+    // enregistrements, comme la lecture des logs.
+    final safePath = SafePath.resolveWithin(recordingsDirPath, path);
+    if (safePath == null) return null;
+
+    return MediaProbe.duration(safePath);
+  }
+
   Map<String, dynamic> _enrich(Recording r, DateTime now) {
     final map = r.toMap();
 

bin/api/streaming_handler.dart

@@ -1,4 +1,3 @@
-import 'dart:async';
 import 'dart:io';
 import 'package:shelf/shelf.dart';
 import 'package:shelf_router/shelf_router.dart';
@@ -7,6 +6,9 @@ import '../database/database.dart';
 import '../models/playlist_config.dart';
 import '../services/ffmpeg_session_manager.dart';
 import '../utils/log_redactor.dart';
+import '../utils/media_probe.dart';
+import '../utils/stream_pipe.dart';
+import 'recording_playlist.dart';
 
 /// Directory for temporary HLS segments
 final Directory _hlsTempDir =
@@ -428,22 +430,17 @@ Handler createLiveStreamHandler(
       }
     });
 
-    // Relayer stdout vers le client ; tuer FFmpeg dès que le client zappe
-    // ou ferme l'onglet (sinon les processus s'accumulent à chaque zap).
-    final controller = StreamController<List<int>>();
-    final subscription = process.stdout.listen(
-      controller.add,
-      onError: controller.addError,
-      onDone: controller.close,
+    // Relayer stdout vers le client en gardant la contre-pression, et tuer
+    // FFmpeg dès que le client zappe ou ferme l'onglet (sinon les processus
+    // s'accumulent à chaque zap).
+    final body = pipeWithBackpressure(
+      process.stdout,
+      onStop: () => process.kill(ProcessSignal.sigterm),
     );
-    controller.onCancel = () {
-      subscription.cancel();
-      process.kill(ProcessSignal.sigterm);
-    };
 
     return Response(
       200,
-      body: controller.stream,
+      body: body,
       headers: {
         'Content-Type': 'video/mp2t',
         'Cache-Control': 'no-store',
@@ -632,6 +629,10 @@ Handler createRecordingStreamHandler(
 
   router.get('/<streamId>/playlist.m3u8',
       (Request request, String streamId) async {
+    if (!_isValidStreamId(streamId)) {
+      return Response.badRequest(body: 'Invalid request');
+    }
+
     final recording = db.getRecordingById(streamId);
     if (recording == null) {
       return Response.notFound('Recording not found');
@@ -660,18 +661,36 @@ Handler createRecordingStreamHandler(
           body: 'Physical recording file not found');
     }
 
-    final useNvidiaGpu = isGpuEnabled?.call() ?? _isNvidiaGpuEnabled();
-    final sessionId = 'rec_$streamId';
+    final start = parseRecordingStart(request.url.queryParameters['start']);
+    final offsetKey = recordingOffsetKey(start);
+    final sessionPrefix = 'rec_${streamId}_t';
+    final sessionId = 'rec_${streamId}_$offsetKey';
 
-    final session = await sessionManager.getOrStart(
-      id: sessionId,
-      isLive: false,
-      ffmpegPath: _getFFmpegPath(),
-      argsBuilder: (dir) => [
+    // La capture est faite en `-c copy` : le fichier contient le codec
+    // d'origine de la chaîne, presque toujours du H.264 — directement
+    // lisible en HLS. Le ré-encoder tenait à peine le temps réel en 1080p,
+    // si bien que la lecture démarrait collée au front d'encodage et se
+    // coupait à la moindre hésitation. En copie, la segmentation va à la
+    // vitesse du disque : l'enregistrement devient navigable en quelques
+    // secondes. Seuls les codecs que le navigateur ne sait pas lire
+    // (HEVC, MPEG-2…) justifient encore un ré-encodage.
+    final videoCodec = await MediaProbe.videoCodec(targetUrl);
+    final canCopyVideo = videoCodec == 'h264';
+
+    List<String> buildArgs({required bool copyVideo}) {
+      final useNvidiaGpu =
+          !copyVideo && (isGpuEnabled?.call() ?? _isNvidiaGpuEnabled());
+      return [
         '-hide_banner', '-loglevel', 'warning',
         if (useNvidiaGpu) ...['-hwaccel', 'cuda'],
+        // -ss AVANT -i : recherche rapide par index, sans décoder ce qui
+        // précède. La sortie repart de 0, le lecteur ré-ajoute l'offset.
+        // En copie, la position atteinte est l'image-clé qui précède.
+        if (start > 0) ...['-ss', '$start'],
         '-i', targetUrl,
-        if (useNvidiaGpu) ...[
+        if (copyVideo) ...[
+          '-c:v', 'copy',
+        ] else if (useNvidiaGpu) ...[
           '-c:v', 'h264_nvenc', '-preset', 'p4', '-tune', 'hq',
           '-rc', 'cbr', '-b:v', '3000k', '-maxrate', '3500k',
           '-bufsize', '6000k',
@@ -686,38 +705,113 @@ Handler createRecordingStreamHandler(
           '-g', '48', '-threads', '0',
         ],
         ..._audioArgs(withFilters: true),
+        // `event` et non `vod` : en VOD, hls.js considère la playlist comme
+        // définitive et ne la relit jamais. Il ne voyait donc que les
+        // quelques secondes déjà transcodées à l'ouverture — d'où une durée
+        // absurde et une barre de progression inutilisable. En `event`, la
+        // playlist est rechargée et la zone navigable grandit avec l'encodage.
         '-f', 'hls', '-hls_time', '4', '-hls_list_size', '0',
-        '-hls_playlist_type', 'vod', '-hls_allow_cache', '1',
+        '-hls_playlist_type', 'event', '-hls_allow_cache', '1',
         '-hls_flags', 'independent_segments', '-hls_segment_type', 'mpegts',
         '-hls_segment_filename', 'segment_%03d.ts', '-start_number', '0',
         'playlist.m3u8',
-      ],
-    );
-
-    final result = await sessionManager.waitForPlaylist(session);
-    if (!result.ready) {
-      sessionManager.killSession(sessionId);
-      return Response(502,
-          body: 'Recording transcoder failed: ${result.error}');
+      ];
     }
 
+    /// Démarre (ou récupère) la session et attend qu'elle ait de l'avance.
+    ///
+    /// Trois segments avant de rendre la main : c'est la marge qui manquait
+    /// au démarrage, la playlist étant servie dès le premier segment. En
+    /// copie vidéo elle est produite en une fraction de seconde, elle ne
+    /// coûte donc que sur un ré-encodage.
+    Future<({FfmpegSession session, bool ready, String? error})> run(
+      bool copyVideo,
+    ) async {
+      if (!sessionManager.contains(sessionId)) {
+        print(
+          '[Recording] $sessionId : '
+          '${copyVideo ? 'copie vidéo' : 'ré-encodage'} '
+          '(codec source : ${videoCodec ?? 'inconnu'})',
+        );
+      }
+      final session = await sessionManager.getOrStart(
+        id: sessionId,
+        isLive: false,
+        ffmpegPath: _getFFmpegPath(),
+        argsBuilder: (dir) => buildArgs(copyVideo: copyVideo),
+      );
+      final outcome =
+          await sessionManager.waitForPlaylist(session, minSegments: 3);
+      return (
+        session: session,
+        ready: outcome.ready,
+        error: outcome.error,
+      );
+    }
+
+    var attempt = await run(canCopyVideo);
+
+    // La copie a échoué : certains conteneurs ou horodatages ne s'y prêtent
+    // pas. Plutôt qu'un écran d'erreur, on retombe sur le ré-encodage, qui
+    // était le seul chemin jusqu'ici.
+    if (!attempt.ready && canCopyVideo) {
+      print(
+        '[Recording] $sessionId : copie vidéo refusée (${attempt.error}) '
+        '— repli sur le ré-encodage',
+      );
+      sessionManager.killSession(sessionId);
+      attempt = await run(false);
+    }
+
+    if (!attempt.ready) {
+      sessionManager.killSession(sessionId);
+      return Response(502,
+          body: 'Recording transcoder failed: ${attempt.error}');
+    }
+
+    final session = attempt.session;
+
     session.touch();
+    // Ménage des offsets abandonnés (aller-retours dans la barre de
+    // progression), une fois la nouvelle session confirmée démarrée.
+    sessionManager.killIdleSiblings(sessionPrefix, keep: sessionId);
+
+    // Les segments sont préfixés par l'offset pour rester rattachés à LEUR
+    // session : `segment_000.ts` d'une playlist à 0 s et d'une playlist à
+    // 45 min sont deux fichiers différents.
+    final playlist = await File('${session.dir.path}/playlist.m3u8')
+        .readAsString();
+
     return Response.ok(
-      File('${session.dir.path}/playlist.m3u8').openRead(),
+      rewriteRecordingPlaylist(playlist, offsetKey),
       headers: _hlsHeaders(),
     );
   });
 
-  router.get('/<streamId>/<segment>',
-      (Request request, String streamId, String segment) async {
-    if (segment.contains('..')) {
+  Response serveSegment(String streamId, String offsetKey, String segment) {
+    if (!_isValidStreamId(streamId) ||
+        parseRecordingOffsetKey(offsetKey) == null ||
+        segment.contains('..') ||
+        segment.contains('/')) {
       return Response.badRequest(body: 'Invalid request');
     }
-    final sessionId = 'rec_$streamId';
+    final sessionId = 'rec_${streamId}_$offsetKey';
     sessionManager.touch(sessionId);
     final file = File('${_hlsTempDir.path}/$sessionId/$segment');
     if (!file.existsSync()) return Response.notFound('Segment not found');
     return Response.ok(file.openRead(), headers: _segmentHeaders(maxAge: 3600));
+  }
+
+  router.get('/<streamId>/<offsetKey>/<segment>',
+      (Request request, String streamId, String offsetKey, String segment) {
+    return serveSegment(streamId, offsetKey, segment);
+  });
+
+  // Compat : playlist servie avant la mise en place des offsets, encore en
+  // cache dans un onglet ouvert.
+  router.get('/<streamId>/<segment>',
+      (Request request, String streamId, String segment) {
+    return serveSegment(streamId, recordingOffsetKey(0), segment);
   });
 
   return router.call;

bin/pubspec.lock

@@ -474,4 +474,4 @@ packages:
     source: hosted
     version: "3.1.3"
 sdks:
-  dart: ">=3.11.0 <4.0.0"
+  dart: ">=3.13.0 <4.0.0"

bin/pubspec.yaml

@@ -4,7 +4,7 @@ publish_to: 'none'
 version: 1.0.0+1
 
 environment:
-  sdk: '>=3.0.0 <4.0.0'
+  sdk: ^3.13.0
 
 dependencies:
   shelf: ^1.4.1

bin/server.dart

@@ -18,7 +18,9 @@ import 'api/streaming_handler.dart';
 import 'api/proxy_handler.dart';
 import 'api/recordings_api.dart';
 import 'api/epg_api.dart';
+import 'api/logo_api.dart';
 import 'services/xmltv_epg_service.dart';
+import 'services/logo_catalog.dart';
 import 'api/season_passes_api.dart';
 import 'api/xtream_api_handler.dart';
 import 'middleware/auth_middleware.dart';
@@ -121,6 +123,9 @@ void main(List<String> args) async {
   final usersHandler = UsersHandler(db);
   final settingsHandler = SettingsHandler(db);
   final proxyHandler = ProxyHandler(getPlaylist, db);
+  // Logos de chaînes : URL du panneau d'abord, puis repli par nom sur le
+  // dépôt public tv-logos quand l'hébergeur de picons du revendeur tombe.
+  final logoApi = LogoApi(proxyHandler.handler, LogoCatalog());
   final recordingsApi = RecordingsApi(db, recordingScheduler);
   // Source XMLTV de repli. Vider EPG_XMLTV_URLS désactive tout appel sortant :
   // l'EPG se limite alors au panneau de l'abonné.
@@ -204,6 +209,14 @@ void main(List<String> args) async {
           .addMiddleware(authMiddleware(db))
           .addHandler(recordingsRouter.call),
     )
+    // Logos de chaînes avec repli (auth required ; le cookie de session
+    // accompagne les requêtes d'image du navigateur)
+    ..get(
+      '/api/logo',
+      const Pipeline()
+          .addMiddleware(authMiddleware(db))
+          .addHandler(logoApi.handle),
+    )
     // EPG - guide TV (auth required)
     ..mount(
       '/api/epg',
@@ -259,6 +272,20 @@ void main(List<String> args) async {
     }),
   );
 
+  // Les libs de lecture sont servies depuis l'image, plus depuis un CDN : si
+  // elles manquent (build web incomplet, copie Docker partielle), le lecteur
+  // échoue côté navigateur avec un simple « Échec du chargement » sans que
+  // rien ne l'ait signalé au démarrage. On le dit ici, une fois, clairement.
+  for (final lib in const ['hls.min.js', 'mpegts.min.js']) {
+    final file = File('$webPath/vendor/$lib');
+    if (!file.existsSync()) {
+      print(
+        '[Server] ATTENTION: web/vendor/$lib absent de $webPath — '
+        'la lecture échouera dans le navigateur.',
+      );
+    }
+  }
+
   // Create static handler
   final baseStaticHandler = createStaticHandler(
     webPath,

bin/services/ffmpeg_session_manager.dart

@@ -143,22 +143,40 @@ class FfmpegSessionManager {
     }
   }
 
-  /// Waits until the session's playlist references at least one segment.
-  /// Fails fast when the process dies before producing output, returning
-  /// the recent stderr for diagnostics.
+  /// Waits until the session's playlist references at least [minSegments]
+  /// segments. Fails fast when the process dies before producing output,
+  /// returning the recent stderr for diagnostics.
+  ///
+  /// [minSegments] > 1 donne au lecteur une avance de démarrage : servir la
+  /// playlist dès le premier segment le fait partir avec 4 s de marge sur un
+  /// encodeur qui n'a pas fini — la moindre hésitation coupe la lecture. La
+  /// playlist déjà close (`#EXT-X-ENDLIST`) est renvoyée telle quelle, quel
+  /// que soit son nombre de segments : rien de plus n'arrivera.
   Future<({bool ready, String? error})> waitForPlaylist(
     FfmpegSession session, {
     Duration timeout = const Duration(seconds: 30),
+    int minSegments = 1,
   }) async {
     final playlistFile = File('${session.dir.path}/playlist.m3u8');
     final deadline = DateTime.now().add(timeout);
 
     while (DateTime.now().isBefore(deadline)) {
-      if (playlistFile.existsSync() &&
-          playlistFile.readAsStringSync().contains('.ts')) {
-        return (ready: true, error: null);
+      if (playlistFile.existsSync()) {
+        final content = playlistFile.readAsStringSync();
+        final segments = '.ts'.allMatches(content).length;
+        if (segments >= minSegments ||
+            (segments > 0 && content.contains('#EXT-X-ENDLIST'))) {
+          return (ready: true, error: null);
+        }
       }
       if (session.exited) {
+        // Un encodeur qui s'est terminé proprement en ayant produit moins de
+        // segments que demandé a simplement fini : c'est un succès.
+        if (session.exitCode == 0 &&
+            playlistFile.existsSync() &&
+            playlistFile.readAsStringSync().contains('.ts')) {
+          return (ready: true, error: null);
+        }
         return (
           ready: false,
           error: 'FFmpeg exited (${session.exitCode}): '
@@ -169,6 +187,11 @@ class FfmpegSessionManager {
       // latence pure entre la disponibilité de la playlist et sa réponse.
       await Future.delayed(const Duration(milliseconds: 100));
     }
+    // Le délai est écoulé : mieux vaut servir ce qui existe que rien.
+    if (playlistFile.existsSync() &&
+        playlistFile.readAsStringSync().contains('.ts')) {
+      return (ready: true, error: null);
+    }
     return (ready: false, error: 'Timeout waiting for transcoder');
   }
 
@@ -185,6 +208,28 @@ class FfmpegSessionManager {
     }
   }
 
+  /// Tue les sessions frères d'un même contenu (`rec_<id>_t0`, `rec_<id>_t600`…)
+  /// que plus personne ne consomme depuis [idleFor].
+  ///
+  /// Chaque saut hors de la zone déjà transcodée démarre un FFmpeg à un
+  /// nouvel offset ; sans ce ménage, une poignée d'allers-retours dans la
+  /// barre de progression laisserait autant de processus vivants jusqu'au
+  /// TTL de 15 minutes. Le délai d'inactivité protège un second spectateur
+  /// du même enregistrement : sa session est « touchée » à chaque segment.
+  void killIdleSiblings(
+    String prefix, {
+    required String keep,
+    Duration idleFor = const Duration(seconds: 30),
+  }) {
+    final now = DateTime.now();
+    for (final session in _sessions.values.toList()) {
+      if (session.id == keep || !session.id.startsWith(prefix)) continue;
+      if (now.difference(session.lastAccess) < idleFor) continue;
+      print('[FFmpegManager] Dropping stale sibling ${session.id}');
+      killSession(session.id);
+    }
+  }
+
   void killAll() {
     print('[FFmpegManager] Killing ${_sessions.length} session(s)');
     for (final id in _sessions.keys.toList()) {

bin/services/logo_catalog.dart

@@ -0,0 +1,239 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+
+/// Logos de chaînes de repli, tirés du dépôt public `tv-logo/tv-logos`.
+///
+/// POURQUOI : les URL `stream_icon` du panneau pointent chez l'hébergeur du
+/// revendeur. Quand cette machine tombe — cas observé : serveur de picons en
+/// maintenance, 503 sur toutes les URL —, toute la grille reste sans logo.
+/// Le dépôt `tv-logos` est maintenu, nommé de façon régulière
+/// (`countries/france/rmc-sport-2-fr.png`) et s'apparie au nom de chaîne.
+class LogoCatalog {
+  LogoCatalog({
+    http.Client? client,
+    this.listingTtl = const Duration(hours: 24),
+    this.retryBackoff = const Duration(minutes: 15),
+  }) : _client = client ?? http.Client();
+
+  final http.Client _client;
+
+  /// Durée de vie d'une liste de logos par pays. L'API GitHub non
+  /// authentifiée plafonne à 60 requêtes par heure : une par jour suffit.
+  final Duration listingTtl;
+
+  /// Recul après un échec de téléchargement de liste (limite de débit,
+  /// réseau), pour ne pas marteler l'API à chaque tuile affichée.
+  final Duration retryBackoff;
+
+  final Map<String, _Listing> _listings = {};
+  final Map<String, Future<_Listing?>> _listingsInFlight = {};
+  final Map<String, DateTime> _listingFailedAt = {};
+  final Map<String, List<int>> _bytes = {};
+
+  /// Octets PNG du logo correspondant à [channelName], ou `null`.
+  Future<List<int>?> logoFor(String channelName) async {
+    final country = countryFolderFor(channelName);
+    final listing = await _listingFor(country);
+    if (listing == null) return null;
+
+    final key = matchLogoKey(channelName, listing.urls.keys);
+    if (key == null) return null;
+
+    final url = listing.urls[key]!;
+    final cached = _bytes[url];
+    if (cached != null) return cached;
+
+    try {
+      final response = await _client
+          .get(Uri.parse(url))
+          .timeout(const Duration(seconds: 20));
+      if (response.statusCode != 200) return null;
+      return _bytes[url] = response.bodyBytes;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  Future<_Listing?> _listingFor(String country) async {
+    final cached = _listings[country];
+    if (cached != null &&
+        DateTime.now().difference(cached.fetchedAt) < listingTtl) {
+      return cached;
+    }
+
+    final failedAt = _listingFailedAt[country];
+    if (failedAt != null &&
+        DateTime.now().difference(failedAt) < retryBackoff) {
+      // Liste périmée plutôt que rien : les logos ne changent pas d'un jour
+      // à l'autre.
+      return cached;
+    }
+
+    // Les tuiles d'une grille arrivent en rafale : une seule requête de liste.
+    return _listingsInFlight[country] ??=
+        _fetchListing(country).whenComplete(() {
+      _listingsInFlight.remove(country);
+    });
+  }
+
+  Future<_Listing?> _fetchListing(String country) async {
+    final url = 'https://api.github.com/repos/tv-logo/tv-logos/contents/'
+        'countries/$country';
+    try {
+      final response = await _client.get(
+        Uri.parse(url),
+        headers: {'Accept': 'application/vnd.github+json'},
+      ).timeout(const Duration(seconds: 20));
+      if (response.statusCode != 200) {
+        throw StateError('HTTP ${response.statusCode}');
+      }
+
+      final urls = <String, String>{};
+      final decoded = json.decode(response.body);
+      if (decoded is List) {
+        for (final entry in decoded) {
+          if (entry is! Map) continue;
+          final name = entry['name']?.toString() ?? '';
+          final download = entry['download_url']?.toString();
+          if (download == null || !name.endsWith('.png')) continue;
+          urls[_keyFromFileName(name)] = download;
+        }
+      }
+
+      final listing = _Listing(urls, DateTime.now());
+      _listings[country] = listing;
+      _listingFailedAt.remove(country);
+      print('[LogoCatalog] $country : ${urls.length} logos');
+      return listing;
+    } catch (e) {
+      _listingFailedAt[country] = DateTime.now();
+      print('[LogoCatalog] liste $country indisponible : $e');
+      return _listings[country];
+    }
+  }
+
+  /// `rmc-sport-2-fr.png` → `rmc-sport-2`.
+  static String _keyFromFileName(String name) {
+    final base = name.substring(0, name.length - '.png'.length);
+    return base.replaceFirst(RegExp(r'-[a-z]{2}$'), '');
+  }
+}
+
+class _Listing {
+  _Listing(this.urls, this.fetchedAt);
+
+  /// Clé normalisée → URL de téléchargement brute.
+  final Map<String, String> urls;
+  final DateTime fetchedAt;
+}
+
+/// Code pays du préfixe panneau → dossier du dépôt `tv-logos`.
+const _countryFolders = {
+  'fr': 'france',
+  'be': 'belgium',
+  'ch': 'switzerland',
+  'uk': 'united-kingdom',
+  'gb': 'united-kingdom',
+  'us': 'united-states',
+  'ca': 'canada',
+  'de': 'germany',
+  'es': 'spain',
+  'it': 'italy',
+  'pt': 'portugal',
+  'nl': 'netherlands',
+};
+
+/// Préfixe pays des noms panneau : `FR - `, `FR: `, `|FR| `.
+final _countryPrefix = RegExp(r'^\W*([A-Za-z]{2})[\s\-:|]+');
+
+/// Dossier `tv-logos` à consulter pour [channelName]. France par défaut :
+/// c'est l'audience de l'application.
+String countryFolderFor(String channelName) {
+  final match = _countryPrefix.firstMatch(channelName);
+  final code = match?.group(1)?.toLowerCase();
+  return _countryFolders[code] ?? 'france';
+}
+
+/// Mots sans rapport avec l'identité de la chaîne : qualité, codec, variante
+/// de flux. Ils sont propres au panneau et absents des noms de logos.
+const _noise = {
+  'fhd', 'uhd', 'hd', 'sd', '4k', '8k', 'hdr', 'hevc', 'h264', 'h265',
+  '1080p', '720p', '50fps', 'fps', 'raw', 'backup', 'vip', 'multi',
+  'vf', 'vo', 'vostfr',
+};
+
+const _accents = {
+  'à': 'a', 'á': 'a', 'â': 'a', 'ä': 'a', 'è': 'e', 'é': 'e', 'ê': 'e',
+  'ë': 'e', 'ì': 'i', 'í': 'i', 'î': 'i', 'ï': 'i', 'ò': 'o', 'ó': 'o',
+  'ô': 'o', 'ö': 'o', 'ù': 'u', 'ú': 'u', 'û': 'u', 'ü': 'u', 'ç': 'c',
+};
+
+List<String> _tokens(String channelName) {
+  var name = channelName;
+  final prefix = _countryPrefix.firstMatch(name);
+  if (prefix != null &&
+      _countryFolders.containsKey(prefix.group(1)!.toLowerCase())) {
+    name = name.substring(prefix.end);
+  }
+
+  final folded = StringBuffer();
+  for (final rune in name.toLowerCase().runes) {
+    final char = String.fromCharCode(rune);
+    folded.write(_accents[char] ?? char);
+  }
+
+  return folded
+      .toString()
+      .replaceAll('+', ' plus ')
+      .replaceAll('&', ' and ')
+      .split(RegExp(r'[^a-z0-9]+'))
+      .where((t) => t.isNotEmpty && !_noise.contains(t))
+      .toList();
+}
+
+/// Clé de logo la plus proche de [channelName] parmi [available], ou `null`.
+///
+/// Par ordre de confiance : nom exact, nom sans « live », variante plus
+/// longue du même identifiant (`bein-sports-1` → `bein-sports-1-french`),
+/// puis la marque sans numéro de canal (`rmc-sport-live-5` → `rmc-sport-1`).
+/// Aucune approximation sur un mot seul : « France » ne doit pas devenir
+/// France 24.
+String? matchLogoKey(String channelName, Iterable<String> available) {
+  final keys = available.toSet();
+  final tokens = _tokens(channelName);
+  if (tokens.isEmpty) return null;
+
+  List<String> withoutLive(List<String> parts) =>
+      parts.where((t) => t != 'live').toList();
+
+  String? exact(List<String> parts) {
+    final slug = parts.join('-');
+    return parts.isNotEmpty && keys.contains(slug) ? slug : null;
+  }
+
+  String? longerVariant(List<String> parts) {
+    if (parts.length < 2) return null;
+    final slug = parts.join('-');
+    final longer = keys.where((k) => k.startsWith('$slug-')).toList()
+      ..sort((a, b) {
+        final byLength = a.length.compareTo(b.length);
+        return byLength != 0 ? byLength : a.compareTo(b);
+      });
+    return longer.isEmpty ? null : longer.first;
+  }
+
+  final noLive = withoutLive(tokens);
+  final direct = exact(tokens) ??
+      exact(noLive) ??
+      longerVariant(tokens) ??
+      longerVariant(noLive);
+  if (direct != null) return direct;
+
+  // Marque sans numéro de canal, seulement s'il reste au moins deux mots.
+  if (RegExp(r'^\d+$').hasMatch(tokens.last)) {
+    final brand = withoutLive(tokens.sublist(0, tokens.length - 1));
+    if (brand.length >= 2) return exact(brand) ?? longerVariant(brand);
+  }
+  return null;
+}

bin/services/xmltv_epg_service.dart

@@ -19,6 +19,9 @@ class XmltvEpgService {
     required this.sourceUrls,
     this.refreshInterval = const Duration(hours: 6),
     this.retention = const Duration(hours: 6),
+    this.horizon = const Duration(hours: 48),
+    this.retryBackoff = const Duration(minutes: 15),
+    this.downloadTimeout = const Duration(minutes: 5),
     http.Client? client,
   }) : _client = client ?? http.Client();
 
@@ -33,11 +36,32 @@ class XmltvEpgService {
   /// garder double la taille de l'index.
   final Duration retention;
 
+  /// Les programmes qui commencent au-delà de cet horizon sont écartés à
+  /// l'indexation.
+  ///
+  /// Un dump national couvre souvent sept jours pour un millier de chaînes ;
+  /// tout garder en mémoire dans le conteneur coûte des centaines de
+  /// mégaoctets pour un guide qui n'affiche que le programme courant et les
+  /// suivants.
+  final Duration horizon;
+
+  /// Délai minimal entre deux tentatives quand aucune source n'a répondu.
+  ///
+  /// Sans ce recul, une source morte était retéléchargée à chaque consultation
+  /// du guide — une requête sortante par chaîne affichée, soit exactement le
+  /// flot qu'un index est censé éviter.
+  final Duration retryBackoff;
+
+  /// Plafond de téléchargement d'un dump. Le guide est facultatif : mieux vaut
+  /// abandonner et servir le panneau que faire attendre l'utilisateur.
+  final Duration downloadTimeout;
+
   final http.Client _client;
 
   /// clé de chaîne normalisée → programmes triés par heure de début.
   Map<String, List<XmltvProgramme>> _index = {};
   DateTime? _indexedAt;
+  DateTime? _failedAt;
   Future<void>? _refreshInFlight;
 
   bool get hasData => _index.isNotEmpty;
@@ -70,6 +94,14 @@ class XmltvEpgService {
         ? null
         : DateTime.now().difference(_indexedAt!);
     if (age != null && age < refreshInterval) return Future.value();
+
+    final sinceFailure = _failedAt == null
+        ? null
+        : DateTime.now().difference(_failedAt!);
+    if (sinceFailure != null && sinceFailure < retryBackoff) {
+      return Future.value();
+    }
+
     return _refreshInFlight ??= _refresh().whenComplete(() {
       _refreshInFlight = null;
     });
@@ -101,19 +133,20 @@ class XmltvEpgService {
 
     if (ok == 0) {
       // Garder l'index précédent plutôt que de servir un guide vide.
+      _failedAt = DateTime.now();
       print('[XmltvEpg] aucune source disponible, index précédent conservé');
       return;
     }
 
     _index = merged;
     _indexedAt = DateTime.now();
+    _failedAt = null;
     print('[XmltvEpg] index prêt : ${merged.length} chaînes');
   }
 
   Future<String> _download(String url) async {
-    final response = await _client
-        .get(Uri.parse(url))
-        .timeout(const Duration(minutes: 5));
+    final response =
+        await _client.get(Uri.parse(url)).timeout(downloadTimeout);
     if (response.statusCode != 200) {
       throw HttpException('HTTP ${response.statusCode}');
     }
@@ -132,6 +165,7 @@ class XmltvEpgService {
 
   Map<String, List<XmltvProgramme>> _parse(String xml) {
     final cutoff = DateTime.now().toUtc().subtract(retention);
+    final limit = DateTime.now().toUtc().add(horizon);
     final byChannel = <String, List<XmltvProgramme>>{};
 
     // Alias : plusieurs dumps déclarent <channel id="X"> avec un
@@ -191,7 +225,8 @@ class XmltvEpgService {
             if (programmeChannel != null &&
                 start != null &&
                 stop != null &&
-                stop.isAfter(cutoff)) {
+                stop.isAfter(cutoff) &&
+                start.isBefore(limit)) {
               final key = normalizeKey(programmeChannel);
               if (key.isNotEmpty) {
                 byChannel.putIfAbsent(key, () => []).add(

bin/test/asset_failure_cache_test.dart

@@ -0,0 +1,57 @@
+import 'package:test/test.dart';
+import '../api/asset_failure_cache.dart';
+
+void main() {
+  group('AssetFailureCache', () {
+    test('un hôte inconnu est considéré joignable', () {
+      final cache = AssetFailureCache();
+      expect(cache.isDown('cdn.example'), isFalse);
+    });
+
+    test('un échec isolé ne coupe pas l’hôte', () {
+      // Un 5xx passager ne doit pas priver l'utilisateur de ses logos
+      // pendant plusieurs minutes.
+      final cache = AssetFailureCache(threshold: 3);
+      cache.recordFailure('cdn.example');
+      expect(cache.isDown('cdn.example'), isFalse);
+    });
+
+    test('coupe l’hôte après le seuil d’échecs consécutifs', () {
+      final cache = AssetFailureCache(threshold: 3);
+      for (var i = 0; i < 3; i++) {
+        cache.recordFailure('cdn.example');
+      }
+      expect(cache.isDown('cdn.example'), isTrue);
+    });
+
+    test('un succès remet le compteur à zéro', () {
+      final cache = AssetFailureCache(threshold: 3);
+      cache.recordFailure('cdn.example');
+      cache.recordFailure('cdn.example');
+      cache.recordSuccess('cdn.example');
+      cache.recordFailure('cdn.example');
+      expect(cache.isDown('cdn.example'), isFalse);
+    });
+
+    test('la coupure expire après le TTL', () {
+      var now = DateTime(2026, 9, 19, 9);
+      final cache = AssetFailureCache(
+        threshold: 1,
+        ttl: const Duration(minutes: 5),
+        clock: () => now,
+      );
+      cache.recordFailure('cdn.example');
+      expect(cache.isDown('cdn.example'), isTrue);
+
+      now = now.add(const Duration(minutes: 6));
+      expect(cache.isDown('cdn.example'), isFalse);
+    });
+
+    test('les hôtes sont indépendants', () {
+      final cache = AssetFailureCache(threshold: 1);
+      cache.recordFailure('mort.example');
+      expect(cache.isDown('mort.example'), isTrue);
+      expect(cache.isDown('vivant.example'), isFalse);
+    });
+  });
+}

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'));
+    });
+  });
 }

bin/test/logo_api_test.dart

@@ -0,0 +1,128 @@
+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/logo_api.dart';
+import '../services/logo_catalog.dart';
+
+/// Catalogue qui connaît uniquement `rmc-sport-2` et sert [bytes].
+LogoCatalog _catalog(List<int> bytes, {void Function()? onUse}) {
+  return LogoCatalog(
+    client: MockClient((request) async {
+      onUse?.call();
+      if (request.url.host == 'api.github.com') {
+        return http.Response(
+          jsonEncode([
+            {
+              'name': 'rmc-sport-2-fr.png',
+              'download_url': 'https://raw.example/rmc-sport-2-fr.png',
+            },
+          ]),
+          200,
+        );
+      }
+      return http.Response.bytes(bytes, 200);
+    }),
+  );
+}
+
+Request _logoRequest(String src, String name) => Request(
+      'GET',
+      Uri.http('localhost:8089', '/api/logo', {'src': src, 'name': name}),
+      headers: {'cookie': 'session=abc'},
+    );
+
+void main() {
+  group('LogoApi', () {
+    test('sert le logo du panneau quand il répond', () async {
+      Request? forwarded;
+      var catalogUsed = false;
+      final api = LogoApi(
+        (request) {
+          forwarded = request;
+          return Response.ok(
+            [9, 9],
+            headers: {'content-type': 'image/png'},
+          );
+        },
+        _catalog([1], onUse: () => catalogUsed = true),
+      );
+
+      final response = await api.handle(
+        _logoRequest('http://picons.example/logos/1.png', 'FR - RMC SPORT 2'),
+      );
+
+      expect(response.statusCode, 200);
+      expect(await response.read().expand((b) => b).toList(), [9, 9]);
+      expect(response.headers['cache-control'], contains('max-age=86400'));
+      expect(catalogUsed, isFalse);
+      // Le proxy reçoit l'URL au format attendu et la session du client.
+      expect(forwarded!.url.path, 'api/xtream/http://picons.example/logos/1.png');
+      expect(forwarded!.headers['cookie'], 'session=abc');
+    });
+
+    test('retombe sur le catalogue quand le panneau échoue', () async {
+      final api = LogoApi(
+        (_) => Response.notFound(null),
+        _catalog([4, 2]),
+      );
+
+      final response = await api.handle(
+        _logoRequest('http://picons.example/logos/1.png', 'FR - RMC SPORT 2'),
+      );
+
+      expect(response.statusCode, 200);
+      expect(response.headers['content-type'], 'image/png');
+      expect(await response.read().expand((b) => b).toList(), [4, 2]);
+    });
+
+    test('ignore une réponse panneau qui n’est pas une image', () async {
+      // Page HTML de maintenance servie en 200 : pas un logo.
+      final api = LogoApi(
+        (_) => Response.ok('<html>', headers: {'content-type': 'text/html'}),
+        _catalog([4, 2]),
+      );
+
+      final response = await api.handle(
+        _logoRequest('http://picons.example/logos/1.png', 'FR - RMC SPORT 2'),
+      );
+
+      expect(await response.read().expand((b) => b).toList(), [4, 2]);
+    });
+
+    test('rend une erreur mise en cache quand rien ne correspond', () async {
+      // Un statut d'erreur laisse le client afficher son icône de repli ; une
+      // image vide donnait une tuile blanche. 410 et non 404 : la Cascade du
+      // serveur rattrape les 404 et perdrait le cache-control.
+      final api = LogoApi(
+        (_) => Response.notFound(null),
+        _catalog([1]),
+      );
+
+      final response = await api.handle(
+        _logoRequest('http://picons.example/logos/1.png', 'FR - INCONNUE'),
+      );
+
+      expect(response.statusCode, 410);
+      expect(response.headers['cache-control'], contains('max-age=600'));
+    });
+
+    test('cherche par nom quand le panneau ne fournit pas de logo', () async {
+      var proxyCalled = false;
+      final api = LogoApi(
+        (_) {
+          proxyCalled = true;
+          return Response.notFound(null);
+        },
+        _catalog([7]),
+      );
+
+      final response = await api.handle(_logoRequest('', 'FR - RMC SPORT 2'));
+
+      expect(response.statusCode, 200);
+      expect(proxyCalled, isFalse);
+    });
+  });
+}

bin/test/logo_catalog_test.dart

@@ -0,0 +1,135 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:test/test.dart';
+import '../services/logo_catalog.dart';
+
+/// Extrait réel de `tv-logo/tv-logos/countries/france` (noms sans `-fr.png`).
+const _france = {
+  'bein-sports-1-french',
+  'bein-sports-2-french',
+  'bein-sports',
+  'canal-plus',
+  'canal-plus-sport',
+  'canal-plus-sport-360',
+  'eurosport-1',
+  'france-2',
+  'france-24',
+  'lequipe',
+  'rmc-sport-1',
+  'rmc-sport-2',
+  'rmc-sport-access-1',
+};
+
+void main() {
+  group('matchLogoKey', () {
+    String? match(String name) => matchLogoKey(name, _france);
+
+    test('correspondance exacte après nettoyage du nom panneau', () {
+      // Préfixe pays et suffixe de qualité sont du bruit propre au panneau.
+      expect(match('FR - RMC SPORT 2 FHD'), 'rmc-sport-2');
+      expect(match('FR: France 2 HD'), 'france-2');
+      expect(match('|FR| EUROSPORT 1 UHD'), 'eurosport-1');
+    });
+
+    test('traduit le « + » de Canal+', () {
+      expect(match('FR - CANAL+ SPORT FHD'), 'canal-plus-sport');
+      expect(match('FR - CANAL+'), 'canal-plus');
+    });
+
+    test('accepte une variante plus longue du même identifiant', () {
+      // Le dépôt nomme `bein-sports-1-french`, le panneau `BEIN SPORTS 1`.
+      expect(match('FR - BEIN SPORTS 1 FHD'), 'bein-sports-1-french');
+    });
+
+    test('retombe sur la marque quand le numéro de canal est inconnu', () {
+      // Les canaux événementiels (« Live 5 ») n'ont pas de logo propre :
+      // celui de la marque vaut mieux qu'une tuile vide.
+      expect(match('FR - RMC SPORT LIVE 5 FHD'), 'rmc-sport-1');
+      expect(match('FR - CANAL+ SPORT 2'), 'canal-plus-sport');
+    });
+
+    test('ne devine pas sur un seul mot', () {
+      // « France » seul ne doit pas donner le logo de France 24.
+      expect(match('FR - FRANCE'), isNull);
+    });
+
+    test('rend null quand rien ne correspond', () {
+      expect(match('FR - DAZN FHD'), isNull);
+      expect(match(''), isNull);
+    });
+  });
+
+  group('countryFolderFor', () {
+    test('lit le préfixe pays du nom', () {
+      expect(countryFolderFor('FR - TF1'), 'france');
+      expect(countryFolderFor('BE: RTL TVI'), 'belgium');
+      expect(countryFolderFor('|UK| BBC ONE'), 'united-kingdom');
+    });
+
+    test('France par défaut sans préfixe reconnu', () {
+      expect(countryFolderFor('TF1 HD'), 'france');
+    });
+  });
+
+  group('LogoCatalog', () {
+    test('télécharge le logo apparié et le garde en cache', () async {
+      final requested = <String>[];
+      final client = MockClient((request) async {
+        requested.add(request.url.toString());
+        if (request.url.host == 'api.github.com') {
+          return http.Response(
+            jsonEncode([
+              {
+                'name': 'rmc-sport-2-fr.png',
+                'download_url': 'https://raw.example/rmc-sport-2-fr.png',
+              },
+              {'name': 'README.md', 'download_url': 'https://raw.example/r'},
+            ]),
+            200,
+          );
+        }
+        return http.Response.bytes([1, 2, 3], 200);
+      });
+
+      final catalog = LogoCatalog(client: client);
+      final first = await catalog.logoFor('FR - RMC SPORT 2 FHD');
+      final second = await catalog.logoFor('FR - RMC SPORT 2 FHD');
+
+      expect(first, [1, 2, 3]);
+      expect(second, [1, 2, 3]);
+      // Une liste et un logo, pas un aller-retour par affichage.
+      expect(requested, hasLength(2));
+    });
+
+    test('rend null sans correspondance, sans télécharger d’image', () async {
+      var downloads = 0;
+      final client = MockClient((request) async {
+        if (request.url.host == 'api.github.com') {
+          return http.Response(jsonEncode(const []), 200);
+        }
+        downloads++;
+        return http.Response.bytes([1], 200);
+      });
+
+      final catalog = LogoCatalog(client: client);
+      expect(await catalog.logoFor('FR - CHAINE INCONNUE'), isNull);
+      expect(downloads, 0);
+    });
+
+    test('espace les tentatives quand la liste est injoignable', () async {
+      var listings = 0;
+      final client = MockClient((request) async {
+        listings++;
+        return http.Response('rate limited', 403);
+      });
+
+      final catalog = LogoCatalog(client: client);
+      await catalog.logoFor('FR - RMC SPORT 2');
+      await catalog.logoFor('FR - RMC SPORT 1');
+
+      expect(listings, 1);
+    });
+  });
+}

bin/test/recording_playlist_test.dart

@@ -0,0 +1,69 @@
+import 'package:test/test.dart';
+import '../api/recording_playlist.dart';
+
+void main() {
+  group('parseRecordingStart', () {
+    test('reads a positive position in seconds', () {
+      expect(parseRecordingStart('2700'), 2700);
+    });
+
+    test('truncates fractions of a second', () {
+      expect(parseRecordingStart('2700.9'), 2700);
+    });
+
+    test('falls back to the beginning when absent or unusable', () {
+      expect(parseRecordingStart(null), 0);
+      expect(parseRecordingStart(''), 0);
+      expect(parseRecordingStart('abc'), 0);
+      expect(parseRecordingStart('-30'), 0);
+      expect(parseRecordingStart('NaN'), 0);
+      expect(parseRecordingStart('Infinity'), 0);
+    });
+  });
+
+  group('recordingOffsetKey', () {
+    test('round-trips through its parser', () {
+      for (final start in [0, 1, 2700, 86400]) {
+        expect(parseRecordingOffsetKey(recordingOffsetKey(start)), start);
+      }
+    });
+
+    test('rejects keys that are not an offset', () {
+      expect(parseRecordingOffsetKey('t'), isNull);
+      expect(parseRecordingOffsetKey('segment_000.ts'), isNull);
+      expect(parseRecordingOffsetKey('..'), isNull);
+      expect(parseRecordingOffsetKey('t-30'), isNull);
+      expect(parseRecordingOffsetKey('tabc'), isNull);
+    });
+  });
+
+  group('rewriteRecordingPlaylist', () {
+    const playlist = '#EXTM3U\n'
+        '#EXT-X-VERSION:3\n'
+        '#EXT-X-TARGETDURATION:4\n'
+        '#EXT-X-PLAYLIST-TYPE:EVENT\n'
+        '#EXTINF:4.000000,\n'
+        'segment_000.ts\n'
+        '#EXTINF:4.000000,\n'
+        'segment_001.ts\n';
+
+    test('binds every segment to its own session directory', () {
+      final rewritten = rewriteRecordingPlaylist(playlist, 't2700');
+      expect(rewritten, contains('t2700/segment_000.ts'));
+      expect(rewritten, contains('t2700/segment_001.ts'));
+      expect(rewritten, isNot(contains('\nsegment_')));
+    });
+
+    test('leaves tags untouched', () {
+      final rewritten = rewriteRecordingPlaylist(playlist, 't0');
+      expect(rewritten, startsWith('#EXTM3U\n#EXT-X-VERSION:3\n'));
+      expect(rewritten, contains('#EXT-X-PLAYLIST-TYPE:EVENT'));
+      expect('#EXTINF:4.000000,'.allMatches(rewritten).length, 2);
+    });
+
+    test('is idempotent on an already rewritten playlist', () {
+      final once = rewriteRecordingPlaylist(playlist, 't60');
+      expect(rewriteRecordingPlaylist(once, 't60'), once);
+    });
+  });
+}

bin/test/stream_pipe_test.dart

@@ -0,0 +1,77 @@
+import 'dart:async';
+
+import 'package:test/test.dart';
+import '../utils/stream_pipe.dart';
+
+void main() {
+  group('pipeWithBackpressure', () {
+    test('relaie les données au client', () async {
+      final source = StreamController<List<int>>();
+      final piped = pipeWithBackpressure(source.stream, onStop: () {});
+
+      final received = <List<int>>[];
+      final done = piped.listen(received.add).asFuture<void>();
+
+      source.add([1, 2, 3]);
+      await source.close();
+      await done;
+
+      expect(received, [
+        [1, 2, 3]
+      ]);
+    });
+
+    test('propage la pause du client vers la source', () async {
+      // Sans cette propagation, un client plus lent que le flux laissait
+      // FFmpeg produire à pleine vitesse et le serveur empilait les paquets
+      // en mémoire : latence qui dérive et lecture qui saccade.
+      var paused = false;
+      var resumed = false;
+      final source = StreamController<List<int>>(
+        onPause: () => paused = true,
+        onResume: () => resumed = true,
+      );
+
+      final subscription = pipeWithBackpressure(
+        source.stream,
+        onStop: () {},
+      ).listen((_) {});
+
+      subscription.pause();
+      await Future<void>.delayed(Duration.zero);
+      expect(paused, isTrue);
+
+      subscription.resume();
+      await Future<void>.delayed(Duration.zero);
+      expect(resumed, isTrue);
+
+      await subscription.cancel();
+      await source.close();
+    });
+
+    test('arrête le producteur quand le client se déconnecte', () async {
+      var stopped = 0;
+      final source = StreamController<List<int>>();
+      final subscription =
+          pipeWithBackpressure(source.stream, onStop: () => stopped++)
+              .listen((_) {});
+
+      await subscription.cancel();
+
+      expect(stopped, 1);
+      await source.close();
+    });
+
+    test('arrête le producteur quand la source se termine', () async {
+      var stopped = 0;
+      final source = StreamController<List<int>>();
+      final piped = pipeWithBackpressure(source.stream, onStop: () => stopped++);
+      final done = piped.listen((_) {}).asFuture<void>();
+
+      await source.close();
+      await done;
+
+      expect(stopped, 1);
+    });
+  });
+}

bin/test/xmltv_epg_test.dart

@@ -1,3 +1,5 @@
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
 import 'package:test/test.dart';
 import '../services/xmltv_epg_service.dart';
 
@@ -101,4 +103,65 @@ void main() {
       expect(index, isEmpty);
     });
   });
+
+  group('ensureFresh', () {
+    test('ne retélécharge pas tant que l’index est frais', () async {
+      final now = DateTime.now().toUtc();
+      var calls = 0;
+      final service = XmltvEpgService(
+        sourceUrls: const ['http://dump.example/epg.xml'],
+        client: MockClient((_) async {
+          calls++;
+          return http.Response(
+            _fixture(now, now.add(const Duration(minutes: 30))),
+            200,
+          );
+        }),
+      );
+
+      await service.ensureFresh();
+      await service.ensureFresh();
+
+      expect(calls, 1);
+      expect(service.hasData, isTrue);
+    });
+
+    test('espace les tentatives après un échec', () async {
+      // Sans ce recul, une source morte était retéléchargée à chaque
+      // consultation du guide : une requête sortante par chaîne affichée.
+      var calls = 0;
+      final service = XmltvEpgService(
+        sourceUrls: const ['http://dump.example/epg.xml'],
+        retryBackoff: const Duration(minutes: 15),
+        client: MockClient((_) async {
+          calls++;
+          return http.Response('nope', 500);
+        }),
+      );
+
+      await service.ensureFresh();
+      await service.ensureFresh();
+      await service.ensureFresh();
+
+      expect(calls, 1);
+      expect(service.hasData, isFalse);
+    });
+  });
+
+  group('horizon', () {
+    test('écarte les programmes au-delà de l’horizon d’indexation', () {
+      // Un dump national couvre sept jours : tout garder ferait grossir
+      // l'index pour un guide qui n'affiche que le programme courant.
+      final service = XmltvEpgService(
+        sourceUrls: const [],
+        horizon: const Duration(hours: 48),
+      );
+      final far = DateTime.now().toUtc().add(const Duration(days: 5));
+
+      expect(
+        service.parseForTest(_fixture(far, far.add(const Duration(hours: 1)))),
+        isEmpty,
+      );
+    });
+  });
 }

bin/utils/media_probe.dart

@@ -0,0 +1,103 @@
+import 'dart:io';
+
+/// Inspection des fichiers média locaux (enregistrements) via ffprobe.
+///
+/// Les résultats sont mémorisés tant que le fichier ne change pas : une
+/// liste d'enregistrements est rafraîchie toutes les 5 s pendant une capture,
+/// et la playlist de lecture est rechargée en continu — sans cache, ffprobe
+/// tournerait en boucle.
+class MediaProbe {
+  MediaProbe._();
+
+  static final Map<String, _CacheEntry> _cache = {};
+
+  /// Binaire ffprobe : l'image Docker l'installe dans `/usr/local/bin`
+  /// à côté de FFmpeg ; `FFPROBE_PATH` permet de le surcharger.
+  static String ffprobePath() {
+    final fromEnv = Platform.environment['FFPROBE_PATH'];
+    if (fromEnv != null && fromEnv.isNotEmpty) return fromEnv;
+    if (Platform.isLinux && File('/usr/local/bin/ffprobe').existsSync()) {
+      return '/usr/local/bin/ffprobe';
+    }
+    return 'ffprobe';
+  }
+
+  /// Durée du média en secondes, ou `null` si elle n'est pas mesurable
+  /// (ffprobe absent, fichier introuvable, conteneur sans durée).
+  static Future<double?> duration(String path) async {
+    final value = await _probe(
+      path,
+      field: 'duration',
+      args: const [
+        '-show_entries', 'format=duration',
+      ],
+    );
+    final seconds = double.tryParse(value ?? '');
+    if (seconds == null || !seconds.isFinite || seconds <= 0) return null;
+    return seconds;
+  }
+
+  /// Codec de la première piste vidéo (`h264`, `hevc`, `mpeg2video`…),
+  /// ou `null` si indéterminable.
+  static Future<String?> videoCodec(String path) async {
+    final value = await _probe(
+      path,
+      field: 'videoCodec',
+      args: const [
+        '-select_streams', 'v:0',
+        '-show_entries', 'stream=codec_name',
+      ],
+    );
+    return (value == null || value.isEmpty) ? null : value.toLowerCase();
+  }
+
+  /// Exécute ffprobe une fois par (fichier, champ) et mémorise le résultat
+  /// tant que taille et date de modification sont inchangées.
+  static Future<String?> _probe(
+    String path, {
+    required String field,
+    required List<String> args,
+  }) async {
+    FileStat stat;
+    try {
+      stat = File(path).statSync();
+      if (stat.type == FileSystemEntityType.notFound) return null;
+    } catch (_) {
+      return null;
+    }
+
+    final key = '$field@$path';
+    final cached = _cache[key];
+    if (cached != null && cached.matches(stat)) return cached.value;
+
+    try {
+      final result = await Process.run(ffprobePath(), [
+        '-v', 'error',
+        ...args,
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        path,
+      ]);
+      // ffprobe imprime une ligne par flux : seule la première nous intéresse.
+      final output = (result.stdout as String).trim().split('\n').first.trim();
+      if (output.isEmpty || output == 'N/A') return null;
+      _cache[key] = _CacheEntry(stat, output);
+      return output;
+    } catch (_) {
+      return null;
+    }
+  }
+}
+
+class _CacheEntry {
+  final int size;
+  final int mtimeMs;
+  final String value;
+
+  _CacheEntry(FileStat stat, this.value)
+      : size = stat.size,
+        mtimeMs = stat.modified.millisecondsSinceEpoch;
+
+  bool matches(FileStat stat) =>
+      stat.size == size &&
+      stat.modified.millisecondsSinceEpoch == mtimeMs;
+}

bin/utils/stream_pipe.dart

@@ -0,0 +1,49 @@
+import 'dart:async';
+
+/// Relaie [source] vers le client en conservant la contre-pression.
+///
+/// POURQUOI : un `StreamController` nu ne transmet pas la pause de son
+/// abonné à la source. Quand le navigateur lit plus lentement que FFmpeg ne
+/// produit — réseau domestique, onglet en arrière-plan —, le serveur empilait
+/// donc les paquets en mémoire sans jamais ralentir le producteur : la
+/// consommation grimpe et la lecture dérive derrière le direct, ce qui se voit
+/// à l'écran comme des saccades.
+///
+/// [onStop] est appelé une seule fois, quand le client se déconnecte ou que la
+/// source se termine : c'est là qu'on tue le processus FFmpeg, sinon il en
+/// reste un par zapping.
+Stream<List<int>> pipeWithBackpressure(
+  Stream<List<int>> source, {
+  required void Function() onStop,
+}) {
+  late final StreamController<List<int>> controller;
+  late final StreamSubscription<List<int>> subscription;
+  var stopped = false;
+
+  void stop() {
+    if (stopped) return;
+    stopped = true;
+    onStop();
+  }
+
+  controller = StreamController<List<int>>(
+    onPause: () => subscription.pause(),
+    onResume: () => subscription.resume(),
+    onCancel: () {
+      final cancelled = subscription.cancel();
+      stop();
+      return cancelled;
+    },
+  );
+
+  subscription = source.listen(
+    controller.add,
+    onError: controller.addError,
+    onDone: () {
+      controller.close();
+      stop();
+    },
+  );
+
+  return controller.stream;
+}

lib/core/api/channel_logo.dart

@@ -0,0 +1,20 @@
+/// URL du logo d'une chaîne, servie par le backend (`/api/logo`).
+///
+/// Le backend tente d'abord [streamIcon] (l'URL fournie par le panneau), puis
+/// cherche un logo par [name] quand l'hébergeur de picons du revendeur ne
+/// répond pas. Le nom est donc transmis même sans `stream_icon` : c'est
+/// souvent le seul moyen d'obtenir un logo.
+///
+/// Une chaîne sans logo trouvé reçoit un statut d'erreur : l'`errorBuilder`
+/// de l'`Image.network` appelante affiche alors son propre repli.
+String channelLogoUrl({required String streamIcon, required String name}) {
+  final icon = streamIcon.trim();
+  return Uri(
+    path: '/api/logo',
+    queryParameters: {
+      if (icon.startsWith('http://') || icon.startsWith('https://'))
+        'src': icon,
+      'name': name,
+    },
+  ).toString();
+}

lib/features/iptv/screens/player_screen.dart

@@ -61,6 +61,29 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
   bool _isMuted = false;
   bool _ignoreStatusUpdates = false;
 
+  /// Fin de la plage réellement navigable, en temps absolu.
+  ///
+  /// Un enregistrement est transcodé au fil de l'eau par FFmpeg : ce qui est
+  /// au-delà de ce point n'existe pas encore côté serveur. Sauter dedans
+  /// suppose de relancer l'encodeur à la position visée.
+  double _seekableEnd = 0;
+
+  /// Décalage du média courant par rapport au début du contenu : un
+  /// enregistrement rouvert à 45 min est transcodé *depuis* 45 min.
+  double _mediaOffset = 0;
+
+  /// Vitesse de lecture (hors direct).
+  double _rate = 1.0;
+
+  /// Un rechargement du flux à une nouvelle position est en cours : les
+  /// positions remontées par l'ancienne iframe ne doivent plus rien écraser.
+  bool _seekReloading = false;
+
+  /// Incrémenté à chaque (re)création de l'iframe : deux vues de plateforme
+  /// ne peuvent pas partager le même identifiant, et il faut un identifiant
+  /// neuf pour que Flutter reconstruise réellement l'iframe.
+  int _viewGeneration = 0;
+
   /// Reflète l'état plein écran du document. Le navigateur peut en sortir
   /// sans passer par notre bouton (touche Échap), d'où l'écoute de
   /// `fullscreenchange` plutôt qu'un simple booléen basculé au clic.
@@ -113,6 +136,15 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
   /// tous les navigateurs visés.
   bool get _documentIsFullscreen => html.document.fullscreenElement != null;
 
+  /// Clé de reprise. Les enregistrements sont préfixés : leur identifiant est
+  /// un UUID stocké dans le même espace de noms que les identifiants VOD.
+  String get _positionKey => widget.streamType == StreamType.recording
+      ? 'rec_${widget.streamId}'
+      : widget.streamId;
+
+  /// La position peut-elle avoir un sens (barre de progression, reprise) ?
+  bool get _isSeekable => widget.streamType != StreamType.live;
+
   void _syncFullscreenState() {
     final value = _documentIsFullscreen;
     if (mounted && value != _isFullscreen) {
@@ -139,9 +171,12 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
       }
 
       // Stable view ID for the instance to prevent iframe reload on rebuild
-      // (orientation change). Includes quality so a quality switch forces a
-      // fresh iframe.
-      _viewId = 'iptv-player-$currentStreamId-${_quality.value}-$_viewIdPrefix';
+      // (orientation change). La génération change à chaque appel : sans
+      // elle, relancer le flux à une autre position réutiliserait la même
+      // vue de plateforme et l'iframe ne serait jamais reconstruite.
+      _viewId =
+          'iptv-player-$currentStreamId-${_quality.value}-$_viewIdPrefix-'
+          '${_viewGeneration++}';
 
       final service = ref.read(xtreamServiceProvider(widget.playlist));
       String streamUrl = '';
@@ -166,7 +201,16 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
           quality: _quality.value,
         );
       } else if (widget.streamType == StreamType.recording) {
-        streamUrl = '${service.backendBaseUrl}/api/recordings/stream/$currentStreamId/playlist.m3u8';
+        // FFmpeg transcode l'enregistrement séquentiellement : reprendre à
+        // 45 min sans le lui dire imposerait d'attendre qu'il y arrive.
+        // `?start=` lui fait démarrer l'encodage à la position demandée.
+        _mediaOffset = (startTimeOverride ?? 0) > 0
+            ? startTimeOverride!.floorToDouble()
+            : 0;
+        final base = '${service.backendBaseUrl}/api/recordings/stream/'
+            '$currentStreamId/playlist.m3u8';
+        streamUrl =
+            _mediaOffset > 0 ? '$base?start=${_mediaOffset.toInt()}' : base;
       }
 
       // Store URL for Lite Player
@@ -204,9 +248,10 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
 
       if (widget.streamType == StreamType.recording) {
         playerSrc += '&is_recording=true';
-      }
-
-      if (startTimeOverride != null) {
+        // Le média commence à l'offset : le lecteur ré-ajoute ce décalage
+        // pour exprimer position et recherches en temps absolu.
+        if (_mediaOffset > 0) playerSrc += '&offset=${_mediaOffset.toInt()}';
+      } else if (startTimeOverride != null && startTimeOverride > 0) {
         playerSrc += '&t=$startTimeOverride';
       }
 
@@ -230,12 +275,20 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
         setState(() {
           _isInitialized = true;
           _isLoading = false;
+          _isPlaying = true;
+          _seekReloading = false;
+          // La nouvelle iframe repart d'une plage navigable vide, qui
+          // grandira au rythme du transcodage.
+          _seekableEnd = _mediaOffset;
+          if (_mediaOffset > 0) _currentPosition = _mediaOffset;
         });
 
         // Force unmute on load (after a short delay to ensure iframe is ready)
         Future.delayed(const Duration(milliseconds: 500), () {
-          if (mounted) {
-            _sendMessage({'type': 'set_volume', 'value': 1.0});
+          if (!mounted) return;
+          _sendMessage({'type': 'set_volume', 'value': _isMuted ? 0.0 : 1.0});
+          if (_rate != 1.0) {
+            _sendMessage({'type': 'set_rate', 'value': _rate});
           }
         });
       }
@@ -258,28 +311,47 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
 
       final type = data['type'];
       if (type == 'playback_position') {
+        // Un rechargement à une autre position est en cours : l'ancienne
+        // iframe continue d'émettre quelques instants, ne pas la laisser
+        // ramener la barre en arrière.
+        if (_seekReloading) return;
+
         final currentTime = (data['currentTime'] as num).toDouble();
         final rawDuration = (data['duration'] as num).toDouble();
         final duration = rawDuration.isFinite ? rawDuration : 0.0;
+        final rawSeekable = data['seekableEnd'];
+        final seekableEnd =
+            rawSeekable is num ? rawSeekable.toDouble() : currentTime;
 
         // Only update position if user is NOT dragging the slider
-        if (!_isSeeking) {
-          setState(() {
+        setState(() {
+          if (!_isSeeking) {
             _currentPosition = currentTime;
             _totalDuration = duration > 0 ? duration : 1;
-          });
-        }
+          }
+          if (seekableEnd.isFinite && seekableEnd > 0) {
+            _seekableEnd = seekableEnd;
+          }
+        });
 
         // Update watch history if relevant. Jamais en live : la « position »
         // d'un flux continu n'a pas de sens et polluait le stockage avec une
         // entrée bidon par chaîne zappée.
         if (currentTime > 0 && widget.streamType != StreamType.live) {
           ref.read(playbackPositionsProvider.notifier).savePosition(
-                widget.streamId,
+                _positionKey,
                 currentTime,
                 duration,
               );
         }
+      } else if (type == 'seek_out_of_range') {
+        // Cible hors de la zone déjà transcodée : seul un redémarrage du
+        // flux à cet instant peut la servir.
+        final target = (data['value'] as num?)?.toDouble();
+        if (target != null) _restartAt(target);
+      } else if (type == 'playback_ended') {
+        setState(() => _isPlaying = false);
+        ref.read(playbackPositionsProvider.notifier).clearPosition(_positionKey);
       } else if (type == 'playback_status') {
         if (!_ignoreStatusUpdates) {
           setState(() => _isPlaying = data['status'] == 'playing');
@@ -345,6 +417,48 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
     }
   }
 
+  /// Recherche à un instant absolu du contenu.
+  ///
+  /// Le lecteur tranche lui-même : saut local s'il a la donnée, sinon il
+  /// répond `seek_out_of_range` et le flux est relancé à cet instant.
+  void _seekTo(double target) {
+    final clamped = target.clamp(0.0, _totalDuration);
+    setState(() => _currentPosition = clamped);
+    _sendMessage({'type': 'seek', 'value': clamped});
+    _onHover();
+  }
+
+  void _seekBy(double delta) => _seekTo(_currentPosition + delta);
+
+  /// Relance le flux à [target] : nouvelle session de transcodage côté
+  /// serveur, donc quelques secondes d'attente — réservé aux sauts que la
+  /// zone déjà transcodée ne couvre pas.
+  void _restartAt(double target) {
+    if (!_isSeekable || _seekReloading) return;
+    // Jamais tout à la fin : FFmpeg lancé au-delà de la dernière image
+    // n'encoderait rien et le lecteur n'aurait qu'une erreur à afficher.
+    final ceiling =
+        _totalDuration > 10 ? _totalDuration - 5 : _totalDuration;
+    final clamped = target.clamp(0.0, ceiling);
+    if (widget.streamType != StreamType.recording) {
+      // VOD/séries : le serveur ne sait pas démarrer ailleurs qu'au début,
+      // on se contente du bord de la zone disponible.
+      _sendMessage({'type': 'seek', 'value': _seekableEnd});
+      return;
+    }
+    setState(() {
+      _seekReloading = true;
+      _currentPosition = clamped;
+    });
+    _initializePlayer(startTimeOverride: clamped, isChannelSwitch: true);
+  }
+
+  void _setRate(double rate) {
+    setState(() => _rate = rate);
+    _sendMessage({'type': 'set_rate', 'value': rate});
+    _onHover();
+  }
+
   void _toggleFullscreen() {
     try {
       if (_documentIsFullscreen) {
@@ -379,6 +493,8 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
     // current position, live restarts at the live edge.
     final resumeAt =
         widget.streamType == StreamType.live ? null : _currentPosition;
+    // Un enregistrement redémarre à cette position côté serveur : sa zone
+    // navigable repart de zéro.
     _initializePlayer(startTimeOverride: resumeAt, isChannelSwitch: true);
   }
 
@@ -408,17 +524,27 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
     }
   }
 
+  /// Sauts proposés par les raccourcis et les boutons.
+  static const _smallStep = 10.0;
+  static const _bigStep = 60.0;
+
+  /// Vitesses de lecture proposées hors direct.
+  static const _rates = <double>[0.5, 0.75, 1.0, 1.25, 1.5, 2.0];
+
   /// Keyboard / TV remote controls:
-  /// space-enter = play/pause, ←/→ = seek ±10s (VOD) or zap (live),
-  /// ↑/↓ = zap (live), M = mute, Esc = exit player.
+  /// space-enter-K = play/pause, ←/→ = seek ±10 s (VOD) or zap (live),
+  /// Maj+←/→ ou J/L = ±60 s, ↑/↓ = zap (live), 0-9 = saut en % du contenu,
+  /// M = mute, F = plein écran, +/- = vitesse, Esc = exit player.
   KeyEventResult _onKeyEvent(FocusNode node, KeyEvent event) {
     if (event is! KeyDownEvent) return KeyEventResult.ignored;
     final isLive = widget.streamType == StreamType.live;
     final key = event.logicalKey;
+    final shift = HardwareKeyboard.instance.isShiftPressed;
 
     if (key == LogicalKeyboardKey.space ||
         key == LogicalKeyboardKey.enter ||
         key == LogicalKeyboardKey.select ||
+        key == LogicalKeyboardKey.keyK ||
         key == LogicalKeyboardKey.mediaPlayPause) {
       _togglePlayPause();
       _onHover();
@@ -433,28 +559,27 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
       _onHover();
       return KeyEventResult.handled;
     }
+    if (key == LogicalKeyboardKey.keyF) {
+      _toggleFullscreen();
+      _onHover();
+      return KeyEventResult.handled;
+    }
     if (key == LogicalKeyboardKey.arrowLeft) {
       if (isLive) {
         _previousChannel();
+        _onHover();
       } else {
-        _sendMessage({
-          'type': 'seek',
-          'value': (_currentPosition - 10).clamp(0, _totalDuration),
-        });
+        _seekBy(shift ? -_bigStep : -_smallStep);
       }
-      _onHover();
       return KeyEventResult.handled;
     }
     if (key == LogicalKeyboardKey.arrowRight) {
       if (isLive) {
         _nextChannel();
+        _onHover();
       } else {
-        _sendMessage({
-          'type': 'seek',
-          'value': (_currentPosition + 10).clamp(0, _totalDuration),
-        });
+        _seekBy(shift ? _bigStep : _smallStep);
       }
-      _onHover();
       return KeyEventResult.handled;
     }
     if (isLive && key == LogicalKeyboardKey.arrowUp) {
@@ -467,9 +592,68 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
       _onHover();
       return KeyEventResult.handled;
     }
+    if (!isLive) {
+      if (key == LogicalKeyboardKey.keyJ) {
+        _seekBy(-_bigStep);
+        return KeyEventResult.handled;
+      }
+      if (key == LogicalKeyboardKey.keyL) {
+        _seekBy(_bigStep);
+        return KeyEventResult.handled;
+      }
+      // 0-9 : saut direct au dixième correspondant du contenu.
+      final decile = _decileFor(key);
+      if (decile != null) {
+        _seekTo(_totalDuration * decile / 10);
+        return KeyEventResult.handled;
+      }
+      if (key == LogicalKeyboardKey.period) {
+        _stepRate(1);
+        return KeyEventResult.handled;
+      }
+      if (key == LogicalKeyboardKey.comma) {
+        _stepRate(-1);
+        return KeyEventResult.handled;
+      }
+    }
     return KeyEventResult.ignored;
   }
 
+  /// Touche 0-9 (rangée du haut ou pavé numérique) → dixième visé.
+  /// Table non `const` : `LogicalKeyboardKey` redéfinit `==`, ce qui interdit
+  /// une table constante.
+  static final Map<LogicalKeyboardKey, int> _digitKeys = {
+    LogicalKeyboardKey.digit0: 0,
+    LogicalKeyboardKey.digit1: 1,
+    LogicalKeyboardKey.digit2: 2,
+    LogicalKeyboardKey.digit3: 3,
+    LogicalKeyboardKey.digit4: 4,
+    LogicalKeyboardKey.digit5: 5,
+    LogicalKeyboardKey.digit6: 6,
+    LogicalKeyboardKey.digit7: 7,
+    LogicalKeyboardKey.digit8: 8,
+    LogicalKeyboardKey.digit9: 9,
+    LogicalKeyboardKey.numpad0: 0,
+    LogicalKeyboardKey.numpad1: 1,
+    LogicalKeyboardKey.numpad2: 2,
+    LogicalKeyboardKey.numpad3: 3,
+    LogicalKeyboardKey.numpad4: 4,
+    LogicalKeyboardKey.numpad5: 5,
+    LogicalKeyboardKey.numpad6: 6,
+    LogicalKeyboardKey.numpad7: 7,
+    LogicalKeyboardKey.numpad8: 8,
+    LogicalKeyboardKey.numpad9: 9,
+  };
+
+  int? _decileFor(LogicalKeyboardKey key) => _digitKeys[key];
+
+  void _stepRate(int direction) {
+    final index = _rates.indexOf(_rate);
+    final next = (index < 0 ? _rates.indexOf(1.0) : index) + direction;
+    if (next < 0 || next >= _rates.length) return;
+    _setRate(_rates[next]);
+  }
+
   String _formatDuration(Duration d) {
     String twoDigits(int n) => n.toString().padLeft(2, '0');
     final hours = twoDigits(d.inHours);
@@ -748,9 +932,28 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
 
                       // Center Loading Indicator (only show when loading)
                       if (_isLoading)
-                        const Center(
-                          child: CircularProgressIndicator(
-                            color: AppColors.primary,
+                        Center(
+                          child: Column(
+                            mainAxisSize: MainAxisSize.min,
+                            children: [
+                              const CircularProgressIndicator(
+                                color: AppColors.primary,
+                              ),
+                              // Un saut hors de la zone transcodée relance
+                              // l'encodeur : quelques secondes d'attente,
+                              // autant dire pourquoi.
+                              if (_seekReloading) ...[
+                                const SizedBox(height: 16),
+                                Text(
+                                  'Reprise à '
+                                  '${_formatDuration(Duration(seconds: _currentPosition.toInt()))}…',
+                                  style: GoogleFonts.karla(
+                                    color: AppColors.onSurfaceVariant,
+                                    fontSize: 14,
+                                  ),
+                                ),
+                              ],
+                            ],
                           ),
                         ),
 
@@ -787,6 +990,11 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
                                         activeTrackColor: AppColors.primary,
                                         inactiveTrackColor:
                                             AppColors.onSurface.withOpacity(0.2),
+                                        // Portion déjà transcodée : navigable
+                                        // instantanément, contrairement au
+                                        // reste qui redémarre l'encodeur.
+                                        secondaryActiveTrackColor:
+                                            AppColors.onSurface.withOpacity(0.4),
                                         thumbColor: AppColors.onSurface,
                                         thumbShape: const RoundSliderThumbShape(
                                           enabledThumbRadius: 8,
@@ -795,7 +1003,12 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
                                             AppColors.primary.withOpacity(0.2),
                                       ),
                                       child: Slider(
-                                        value: _currentPosition,
+                                        value: _currentPosition
+                                            .clamp(0.0, _totalDuration),
+                                        secondaryTrackValue: _seekableEnd > 0
+                                            ? _seekableEnd
+                                                .clamp(0.0, _totalDuration)
+                                            : null,
                                         min: 0,
                                         max: _totalDuration,
                                         onChanged: (val) => setState(
@@ -804,9 +1017,7 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
                                         onChangeStart: (_) =>
                                             setState(() => _isSeeking = true),
                                         onChangeEnd: (val) {
-                                          _sendMessage(
-                                            {'type': 'seek', 'value': val},
-                                          );
+                                          _seekTo(val);
                                           Future.delayed(
                                               const Duration(milliseconds: 500),
                                               () {
@@ -836,68 +1047,91 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
                               const SizedBox(height: 12),
 
                               // Buttons
-                              Row(
-                                mainAxisAlignment: MainAxisAlignment.center,
-                                children: [
-                                  _buildGlassIconButton(
-                                    icon: Icons.replay_10_rounded,
-                                    onTap: () => _sendMessage({
-                                      'type': 'seek',
-                                      'value': (_currentPosition - 10)
-                                          .clamp(0, _totalDuration),
-                                    }),
-                                    transparent: true,
-                                    tooltip: 'Reculer de 10 s',
-                                  ),
-                                  const SizedBox(width: 24),
-                                  _buildGlassIconButton(
-                                    icon: _isPlaying
-                                        ? Icons.pause_rounded
-                                        : Icons.play_arrow_rounded,
-                                    onTap: _togglePlayPause,
-                                    size: 56,
-                                    iconSize: 32,
-                                    tooltip: _isPlaying ? 'Pause' : 'Lecture',
-                                  ),
-                                  const SizedBox(width: 24),
-                                  _buildGlassIconButton(
-                                    icon: Icons.forward_10_rounded,
-                                    onTap: () => _sendMessage({
-                                      'type': 'seek',
-                                      'value': (_currentPosition + 10)
-                                          .clamp(0, _totalDuration),
-                                    }),
-                                    transparent: true,
-                                    tooltip: 'Avancer de 10 s',
-                                  ),
-                                  const Spacer(),
-                                  QualitySelectorButton(
-                                    current: _quality,
-                                    onSelected: _changeQuality,
-                                  ),
-                                  const SizedBox(width: 16),
-                                  _buildGlassIconButton(
-                                    icon: _isMuted
-                                        ? Icons.volume_off_rounded
-                                        : Icons.volume_up_rounded,
-                                    onTap: _toggleMute,
-                                    transparent: true,
-                                    tooltip: _isMuted
-                                        ? 'Activer le son'
-                                        : 'Couper le son',
-                                  ),
-                                  const SizedBox(width: 16),
-                                  _buildGlassIconButton(
-                                    icon: _isFullscreen
-                                        ? Icons.fullscreen_exit_rounded
-                                        : Icons.fullscreen_rounded,
-                                    onTap: _toggleFullscreen,
-                                    transparent: true,
-                                    tooltip: _isFullscreen
-                                        ? 'Quitter le plein écran'
-                                        : 'Plein écran',
-                                  ),
-                                ],
+                              LayoutBuilder(
+                                builder: (context, constraints) {
+                                  // Sous 720 px, les sauts de 60 s et le
+                                  // sélecteur de vitesse sortent de la barre
+                                  // plutôt que de la faire déborder.
+                                  final compact = constraints.maxWidth < 720;
+                                  return Row(
+                                    mainAxisAlignment: MainAxisAlignment.center,
+                                    children: [
+                                      if (!compact) ...[
+                                        _buildGlassIconButton(
+                                          icon: Icons.fast_rewind_rounded,
+                                          onTap: () => _seekBy(-_bigStep),
+                                          transparent: true,
+                                          tooltip: 'Reculer de 1 min',
+                                        ),
+                                        const SizedBox(width: 16),
+                                      ],
+                                      _buildGlassIconButton(
+                                        icon: Icons.replay_10_rounded,
+                                        onTap: () => _seekBy(-_smallStep),
+                                        transparent: true,
+                                        tooltip: 'Reculer de 10 s',
+                                      ),
+                                      const SizedBox(width: 24),
+                                      _buildGlassIconButton(
+                                        icon: _isPlaying
+                                            ? Icons.pause_rounded
+                                            : Icons.play_arrow_rounded,
+                                        onTap: _togglePlayPause,
+                                        size: 56,
+                                        iconSize: 32,
+                                        tooltip:
+                                            _isPlaying ? 'Pause' : 'Lecture',
+                                      ),
+                                      const SizedBox(width: 24),
+                                      _buildGlassIconButton(
+                                        icon: Icons.forward_10_rounded,
+                                        onTap: () => _seekBy(_smallStep),
+                                        transparent: true,
+                                        tooltip: 'Avancer de 10 s',
+                                      ),
+                                      if (!compact) ...[
+                                        const SizedBox(width: 16),
+                                        _buildGlassIconButton(
+                                          icon: Icons.fast_forward_rounded,
+                                          onTap: () => _seekBy(_bigStep),
+                                          transparent: true,
+                                          tooltip: 'Avancer de 1 min',
+                                        ),
+                                      ],
+                                      const Spacer(),
+                                      if (!compact) ...[
+                                        _buildRateSelector(),
+                                        const SizedBox(width: 16),
+                                      ],
+                                      QualitySelectorButton(
+                                        current: _quality,
+                                        onSelected: _changeQuality,
+                                      ),
+                                      const SizedBox(width: 16),
+                                      _buildGlassIconButton(
+                                        icon: _isMuted
+                                            ? Icons.volume_off_rounded
+                                            : Icons.volume_up_rounded,
+                                        onTap: _toggleMute,
+                                        transparent: true,
+                                        tooltip: _isMuted
+                                            ? 'Activer le son'
+                                            : 'Couper le son',
+                                      ),
+                                      const SizedBox(width: 16),
+                                      _buildGlassIconButton(
+                                        icon: _isFullscreen
+                                            ? Icons.fullscreen_exit_rounded
+                                            : Icons.fullscreen_rounded,
+                                        onTap: _toggleFullscreen,
+                                        transparent: true,
+                                        tooltip: _isFullscreen
+                                            ? 'Quitter le plein écran'
+                                            : 'Plein écran',
+                                      ),
+                                    ],
+                                  );
+                                },
                               ),
                             ],
                           ),
@@ -914,6 +1148,73 @@ class _PlayerScreenState extends ConsumerState<PlayerScreen> {
     );
   }
 
+  /// Sélecteur de vitesse de lecture — utile pour parcourir un
+  /// enregistrement long sans sauter à l'aveugle.
+  Widget _buildRateSelector() {
+    return Tooltip(
+      message: 'Vitesse de lecture',
+      child: PopupMenuButton<double>(
+        initialValue: _rate,
+        onSelected: _setRate,
+        color: AppColors.surfaceContainer,
+        tooltip: '',
+        itemBuilder: (context) => [
+          for (final rate in _rates)
+            PopupMenuItem<double>(
+              value: rate,
+              child: Row(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  Icon(
+                    rate == _rate
+                        ? Icons.check_rounded
+                        : Icons.speed_rounded,
+                    size: 16,
+                    color: rate == _rate
+                        ? AppColors.primary
+                        : AppColors.onSurfaceVariant,
+                  ),
+                  const SizedBox(width: 8),
+                  Text(
+                    _formatRate(rate),
+                    style: TextStyle(
+                      color: rate == _rate
+                          ? AppColors.primary
+                          : AppColors.onSurface,
+                    ),
+                  ),
+                ],
+              ),
+            ),
+        ],
+        child: Container(
+          height: 40,
+          padding: const EdgeInsets.symmetric(horizontal: 14),
+          alignment: Alignment.center,
+          decoration: BoxDecoration(
+            borderRadius: BorderRadius.circular(20),
+            border: Border.all(color: AppColors.onSurface.withOpacity(0.15)),
+          ),
+          child: Text(
+            _formatRate(_rate),
+            style: GoogleFonts.karla(
+              color: _rate == 1.0 ? AppColors.onSurface : AppColors.primary,
+              fontWeight: FontWeight.w600,
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
+  /// « 1× », « 1.5× » — sans décimale inutile.
+  static String _formatRate(double rate) {
+    final text = rate == rate.roundToDouble()
+        ? rate.toStringAsFixed(0)
+        : rate.toString();
+    return '$text×';
+  }
+
   Widget _buildGlassIconButton({
     required IconData icon,
     required VoidCallback onTap,

lib/features/iptv/widgets/live_tv_tab.dart

@@ -5,6 +5,7 @@ import '../providers/xtream_provider.dart';
 import '../providers/settings_provider.dart';
 import '../providers/favorites_provider.dart';
 import '../screens/player_screen.dart';
+import '../../../core/api/channel_logo.dart';
 import '../../../core/models/iptv_models.dart';
 import '../../../core/models/playlist_config.dart';
 import '../../../core/theme/app_colors.dart';
@@ -412,25 +413,26 @@ class _LiveTVTabState extends ConsumerState<LiveTVTab>
                         ),
                         padding: const EdgeInsets.all(16),
                         child: Center(
-                          child: channel.streamIcon.isNotEmpty
-                              ? Image.network(
-                                  _getProxiedIconUrl(channel.streamIcon)!,
-                                  cacheWidth: 160,
-                                  filterQuality: FilterQuality.low,
-                                  errorBuilder: (_, __, ___) => Icon(
-                                    Icons.tv,
-                                    color: AppColors.onSurface.withOpacity(0.3),
-                                    size: 40,
-                                  ),
-                                )
-                              : Text(
-                                  channel.name.characters.first.toUpperCase(),
-                                  style: GoogleFonts.fraunces(
-                                    fontSize: 40,
-                                    fontWeight: FontWeight.bold,
-                                    color: AppColors.onSurface24,
-                                  ),
-                                ),
+                          // Toujours demandé au backend, même sans
+                          // stream_icon : il cherche alors un logo par nom.
+                          child: Image.network(
+                            channelLogoUrl(
+                              streamIcon: channel.streamIcon,
+                              name: channel.name,
+                            ),
+                            cacheWidth: 160,
+                            filterQuality: FilterQuality.low,
+                            errorBuilder: (_, __, ___) => Text(
+                              channel.name.isEmpty
+                                  ? '?'
+                                  : channel.name.characters.first.toUpperCase(),
+                              style: GoogleFonts.fraunces(
+                                fontSize: 40,
+                                fontWeight: FontWeight.bold,
+                                color: AppColors.onSurface24,
+                              ),
+                            ),
+                          ),
                         ),
                       ),
                     ),
@@ -599,14 +601,6 @@ class _LiveTVTabState extends ConsumerState<LiveTVTab>
     );
   }
 
-  String? _getProxiedIconUrl(String originalUrl) {
-    if (originalUrl.isEmpty) return null;
-    if (originalUrl.startsWith('http://')) {
-      return '/api/xtream/$originalUrl';
-    }
-    return originalUrl;
-  }
-
   void _playChannel(Channel channel, List<Channel> contextList) {
     Navigator.of(context).push(
       MaterialPageRoute(

lib/features/iptv/widgets/recordings_tab.dart

@@ -5,9 +5,11 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:google_fonts/google_fonts.dart';
 import '../../../core/api/authed_http.dart';
 import '../../../core/api/recording_requests.dart';
+import '../../../core/api/channel_logo.dart';
 import '../../../core/models/iptv_models.dart';
 import '../../../core/models/playlist_config.dart';
 import '../../../core/theme/app_colors.dart';
+import '../providers/playback_positions_provider.dart';
 import '../providers/recordings_refresh.dart';
 import '../providers/xtream_provider.dart';
 import '../providers/settings_provider.dart';
@@ -367,25 +369,25 @@ class _EpgGuideViewState extends ConsumerState<_EpgGuideView>
                                     ),
                                     child: Row(
                                       children: [
-                                        ch.streamIcon.isNotEmpty
-                                            ? Image.network(
-                                                ch.streamIcon,
-                                                width: 24,
-                                                height: 16,
-                                                cacheWidth: 64,
-                                                fit: BoxFit.contain,
-                                                errorBuilder: (_, __, ___) =>
-                                                    const Icon(
-                                                  Icons.tv,
-                                                  color: AppColors.onSurface24,
-                                                  size: 16,
-                                                ),
-                                              )
-                                            : const Icon(
-                                                Icons.tv,
-                                                color: AppColors.onSurface24,
-                                                size: 16,
-                                              ),
+                                        // URL panneau brute auparavant : en
+                                        // http depuis une page https, le
+                                        // navigateur la bloquait.
+                                        Image.network(
+                                          channelLogoUrl(
+                                            streamIcon: ch.streamIcon,
+                                            name: ch.name,
+                                          ),
+                                          width: 24,
+                                          height: 16,
+                                          cacheWidth: 64,
+                                          fit: BoxFit.contain,
+                                          errorBuilder: (_, __, ___) =>
+                                              const Icon(
+                                            Icons.tv,
+                                            color: AppColors.onSurface24,
+                                            size: 16,
+                                          ),
+                                        ),
                                         const SizedBox(width: 10),
                                         Expanded(
                                           child: Text(
@@ -780,14 +782,15 @@ class _ProgrammeCard extends StatelessWidget {
 //  ONGLET 2 — ENREGISTREMENTS
 // ═══════════════════════════════════════════════════════════════════════════
 
-class _RecordingsListView extends StatefulWidget {
+class _RecordingsListView extends ConsumerStatefulWidget {
   final PlaylistConfig playlist;
   const _RecordingsListView({required this.playlist});
   @override
-  State<_RecordingsListView> createState() => _RecordingsListViewState();
+  ConsumerState<_RecordingsListView> createState() =>
+      _RecordingsListViewState();
 }
 
-class _RecordingsListViewState extends State<_RecordingsListView> {
+class _RecordingsListViewState extends ConsumerState<_RecordingsListView> {
   List<dynamic> _recordings = [];
   bool _isLoading = true;
   String? _error;
@@ -917,6 +920,35 @@ class _RecordingsListViewState extends State<_RecordingsListView> {
     _fetchRecordings();
   }
 
+  /// Clé de reprise d'un enregistrement (même convention que le lecteur).
+  static String _resumeKey(String recordingId) => 'rec_$recordingId';
+
+  /// Position sauvegardée, ou 0 s'il n'y en a pas d'exploitable.
+  double _savedPosition(Map<String, dynamic> rec) {
+    final id = rec['id'] as String?;
+    if (id == null || id.isEmpty) return 0;
+    return ref.read(playbackPositionsProvider).getPosition(_resumeKey(id));
+  }
+
+  /// Durée du média : celle mesurée par le serveur si disponible, sinon la
+  /// durée programmée. Un enregistrement arrêté en avance est plus court que
+  /// `end_time - start_time`.
+  Duration? _recordingDuration(Map<String, dynamic> rec) {
+    final probed = rec['duration_seconds'];
+    if (probed is num && probed > 0) {
+      return Duration(seconds: probed.round());
+    }
+    try {
+      if (rec['start_time'] != null && rec['end_time'] != null) {
+        final start = DateTime.parse(rec['start_time'].toString());
+        final end = DateTime.parse(rec['end_time'].toString());
+        final scheduled = end.difference(start);
+        if (scheduled > Duration.zero) return scheduled;
+      }
+    } catch (_) {}
+    return null;
+  }
+
   Future<void> _playRecording(BuildContext context, Map<String, dynamic> rec) async {
     final recordingId = rec['id'] as String?;
     final title = rec['title'] as String? ?? 'Enregistrement';
@@ -928,17 +960,52 @@ class _RecordingsListViewState extends State<_RecordingsListView> {
       return;
     }
 
-    Duration? recordingDuration;
-    try {
-      if (rec['start_time'] != null && rec['end_time'] != null) {
-        final start = DateTime.parse(rec['start_time'].toString());
-        final end = DateTime.parse(rec['end_time'].toString());
-        recordingDuration = end.difference(start);
+    final recordingDuration = _recordingDuration(rec);
+    final saved = _savedPosition(rec);
+
+    // Reprise proposée, jamais imposée : un enregistrement déjà vu se
+    // relance parfois depuis le début.
+    double? startAt;
+    if (saved > 30) {
+      if (!mounted) return;
+      final resume = await showDialog<bool>(
+        context: context,
+        builder: (ctx) => AlertDialog(
+          backgroundColor: AppColors.surfaceContainer,
+          title: Text(
+            'Reprendre la lecture ?',
+            style: GoogleFonts.fraunces(color: AppColors.onSurface),
+          ),
+          content: Text(
+            '« $title » a été interrompu à '
+            '${PlaybackPositionsNotifier.formatTime(saved)}.',
+            style: const TextStyle(color: AppColors.onSurfaceVariant),
+          ),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.pop(ctx, false),
+              child: const Text('Depuis le début'),
+            ),
+            ElevatedButton.icon(
+              onPressed: () => Navigator.pop(ctx, true),
+              icon: const Icon(Icons.play_arrow_rounded, size: 18),
+              label: const Text('Reprendre'),
+            ),
+          ],
+        ),
+      );
+      if (resume == null) return; // dialogue fermé : on n'ouvre rien
+      if (resume) {
+        startAt = saved;
+      } else {
+        ref
+            .read(playbackPositionsProvider.notifier)
+            .clearPosition(_resumeKey(recordingId));
       }
-    } catch (_) {}
+    }
 
     if (!mounted) return;
-    Navigator.of(context).push(
+    await Navigator.of(context).push(
       MaterialPageRoute(
         builder: (ctx) => PlayerScreen(
           streamId: recordingId,
@@ -947,9 +1014,51 @@ class _RecordingsListViewState extends State<_RecordingsListView> {
           streamType: StreamType.recording,
           containerExtension: 'ts',
           duration: recordingDuration,
+          startTime: startAt,
         ),
       ),
     );
+    // Au retour du lecteur, la progression affichée dans la liste doit
+    // refléter la position atteinte.
+    if (mounted) setState(() {});
+  }
+
+  /// Barre « déjà vu jusqu'ici » sous un enregistrement entamé.
+  List<Widget> _buildResumeIndicator(Map<String, dynamic> rec) {
+    final saved = _savedPosition(rec);
+    if (saved <= 30) return const [];
+
+    final total = _recordingDuration(rec)?.inSeconds ?? 0;
+    final ratio = total > 0 ? (saved / total).clamp(0.0, 1.0) : null;
+
+    return [
+      const SizedBox(height: 6),
+      Row(
+        children: [
+          if (ratio != null)
+            Expanded(
+              child: ClipRRect(
+                borderRadius: BorderRadius.circular(3),
+                child: LinearProgressIndicator(
+                  value: ratio,
+                  minHeight: 4,
+                  backgroundColor: AppColors.onSurface.withOpacity(0.1),
+                  valueColor:
+                      const AlwaysStoppedAnimation(AppColors.primary),
+                ),
+              ),
+            ),
+          if (ratio != null) const SizedBox(width: 8),
+          Text(
+            'Reprendre à ${PlaybackPositionsNotifier.formatTime(saved)}',
+            style: const TextStyle(
+              color: AppColors.primary,
+              fontSize: 11,
+            ),
+          ),
+        ],
+      ),
+    ];
   }
 
   Future<void> _showLogs(String id, String title) async {
@@ -1037,6 +1146,10 @@ class _RecordingsListViewState extends State<_RecordingsListView> {
 
   @override
   Widget build(BuildContext context) {
+    // Les positions de reprise arrivent de façon asynchrone (SharedPreferences)
+    // et changent au retour du lecteur : sans cette écoute, la mention
+    // « Reprendre à … » n'apparaîtrait qu'au prochain rafraîchissement.
+    ref.watch(playbackPositionsProvider);
     return Padding(
       padding: const EdgeInsets.all(16),
       child: Column(
@@ -1178,6 +1291,8 @@ class _RecordingsListViewState extends State<_RecordingsListView> {
                                           ),
                                         ),
                                       ],
+                                      if (status == 'completed')
+                                        ..._buildResumeIndicator(rec),
                                       if (rec['error_reason'] != null)
                                         Text(
                                           '⚠ ${rec['error_reason']}',
@@ -1228,13 +1343,18 @@ class _RecordingsListViewState extends State<_RecordingsListView> {
                                         ),
                                       if (status == 'completed')
                                         IconButton(
-                                          icon: const Icon(
-                                            Icons.play_circle_outline,
+                                          icon: Icon(
+                                            _savedPosition(rec) > 30
+                                                ? Icons.play_circle_fill
+                                                : Icons.play_circle_outline,
                                             color: AppColors.success,
                                             size: 20,
                                           ),
-                                          tooltip: 'Lecture',
-                                          onPressed: () => _playRecording(context, rec),
+                                          tooltip: _savedPosition(rec) > 30
+                                              ? 'Reprendre'
+                                              : 'Lecture',
+                                          onPressed: () =>
+                                              _playRecording(context, rec),
                                         ),
                                       IconButton(
                                         icon: const Icon(

lib/mobile/features/iptv/widgets/mobile_live_tv_tab.dart

@@ -5,6 +5,7 @@ import '../../../../features/iptv/providers/xtream_provider.dart';
 import '../../../../features/iptv/providers/settings_provider.dart';
 import '../../../../features/iptv/providers/favorites_provider.dart';
 import '../screens/mobile_player_screen.dart';
+import '../../../../core/api/channel_logo.dart';
 import '../../../../core/models/iptv_models.dart';
 import '../../../../core/models/playlist_config.dart';
 import '../../../../core/theme/app_colors.dart';
@@ -349,10 +350,10 @@ class _MobileChannelTile extends ConsumerWidget {
     // Sans ce bouton, aucun moyen d'ajouter un favori : le filtre « Favoris »
     // de l'en-tête affichait toujours une liste vide.
     final isFav = ref.watch(favoritesProvider).contains(channel.streamId);
-    final iconUrl =
-        channel.streamIcon.isNotEmpty && channel.streamIcon.startsWith('http')
-            ? '/api/xtream/${channel.streamIcon}'
-            : null;
+    final iconUrl = channelLogoUrl(
+      streamIcon: channel.streamIcon,
+      name: channel.name,
+    );
 
     return GlassContainer.glass(
       borderRadius: 12,
@@ -372,16 +373,14 @@ class _MobileChannelTile extends ConsumerWidget {
                   borderRadius: BorderRadius.circular(8),
                 ),
                 padding: const EdgeInsets.all(4),
-                child: iconUrl != null
-                    ? Image.network(
-                        iconUrl,
-                        fit: BoxFit.contain,
-                        cacheWidth: 120,
-                        filterQuality: FilterQuality.low,
-                        errorBuilder: (_, __, ___) =>
-                            const Icon(Icons.tv, color: AppColors.onSurface24),
-                      )
-                    : const Icon(Icons.tv, color: AppColors.onSurface24),
+                child: Image.network(
+                  iconUrl,
+                  fit: BoxFit.contain,
+                  cacheWidth: 120,
+                  filterQuality: FilterQuality.low,
+                  errorBuilder: (_, __, ___) =>
+                      const Icon(Icons.tv, color: AppColors.onSurface24),
+                ),
               ),
               const SizedBox(width: 16),
               Expanded(

pubspec.lock

@@ -1262,5 +1262,5 @@ packages:
     source: hosted
     version: "3.1.3"
 sdks:
-  dart: ">=3.10.3 <4.0.0"
+  dart: ">=3.13.0 <4.0.0"
   flutter: ">=3.38.4"

pubspec.yaml

@@ -4,7 +4,7 @@ publish_to: 'none'
 version: 1.0.0+1
 
 environment:
-  sdk: '>=3.0.0 <4.0.0'
+  sdk: ^3.13.0
 
 dependencies:
   flutter:

test/core/channel_logo_test.dart

@@ -0,0 +1,32 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:xtremflow/core/api/channel_logo.dart';
+
+void main() {
+  group('channelLogoUrl', () {
+    test('transmet l’URL panneau et le nom, encodés', () {
+      final url = Uri.parse(
+        channelLogoUrl(
+          streamIcon: 'http://picons.example/logos/1.png?x=1&y=2',
+          name: 'FR - CANAL+ SPORT',
+        ),
+      );
+
+      expect(url.path, '/api/logo');
+      expect(
+        url.queryParameters['src'],
+        'http://picons.example/logos/1.png?x=1&y=2',
+      );
+      // Le « + » doit survivre à l'encodage : sinon Canal+ devient « Canal ».
+      expect(url.queryParameters['name'], 'FR - CANAL+ SPORT');
+    });
+
+    test('envoie le nom seul sans stream_icon exploitable', () {
+      // Sans URL panneau, le nom reste le seul moyen de trouver un logo.
+      for (final icon in ['', '   ', 'logo.png']) {
+        final url = Uri.parse(channelLogoUrl(streamIcon: icon, name: 'TF1'));
+        expect(url.queryParameters.containsKey('src'), isFalse);
+        expect(url.queryParameters['name'], 'TF1');
+      }
+    });
+  });
+}

web/player.html

@@ -11,7 +11,35 @@
       et environ 200 Ko de JS jamais téléchargés dans le cas courant.
     -->
     <link rel="stylesheet" href="xf-player.css">
-    <link rel="preload" href="vendor/hls.min.js" as="script">
+    <script>
+        // Précharge la SEULE lib utile à CE flux, dès le parse du <head>.
+        // Un préchargement fixe de hls.js faisait télécharger 618 Ko inutiles
+        // à chaque zap TV — la lib réellement nécessaire au direct est
+        // mpegts.js — et cette bande passante était prise sur le flux
+        // lui-même et sur mpegts.js, jusqu'à faire échouer son chargement sur
+        // les liens contraints. Même décision que XFPlayer.start().
+        (function () {
+            var p = new URLSearchParams(location.search);
+            var url = (p.get('url') || '').toLowerCase();
+            var isHls = url.indexOf('.m3u8') !== -1;
+            var nativeHls =
+                document.createElement('video')
+                    .canPlayType('application/vnd.apple.mpegurl') !== '';
+            var lib = null;
+            if (isHls) {
+                // Safari/iOS lit le HLS nativement : aucune lib à charger.
+                if (!nativeHls) lib = 'hls.min.js';
+            } else if (p.get('type') === 'live' || url.indexOf('.ts') !== -1) {
+                lib = 'mpegts.min.js';
+            }
+            if (!lib) return;
+            var l = document.createElement('link');
+            l.rel = 'preload';
+            l.as = 'script';
+            l.href = 'vendor/' + lib;
+            document.head.appendChild(l);
+        })();
+    </script>
 </head>
 
 <body>
@@ -68,35 +96,60 @@
                 playOverlay.style.display = 'none';
             }
 
-            var player = new XFPlayer({
-                video: video,
-                logPrefix: '[Player]',
-                onLoading: showLoading,
-                onReady: function () {
-                    hideLoading();
-                    playOverlay.style.display = 'none';
-                },
-                onError: showError,
-                onBlocked: function () {
-                    hideLoading();
-                    playOverlay.style.display = 'flex';
-                },
-                onProfileChange: function (name) {
-                    // Retour visuel discret : l'utilisateur comprend pourquoi
-                    // la latence augmente légèrement après des coupures.
-                    loadingHint.textContent =
-                        name === 'safe' ? 'Réseau instable — buffer maximal'
-                                        : 'Réseau instable — buffer élargi';
-                }
-            });
+            // Un enregistrement ou un film démarre une session FFmpeg côté
+            // serveur : le premier essai peut tomber pendant que l'encodeur
+            // se met en route. Le player mobile réessayait déjà seul ; ici
+            // l'utilisateur devait relancer la lecture à la main.
+            var retryCount = 0;
+            var maxRetries = 3;
+            var player = null;
+
+            function buildPlayer() {
+                if (player) { try { player.destroy(); } catch (e) {} }
+
+                player = new XFPlayer({
+                    video: video,
+                    logPrefix: '[Player]',
+                    onLoading: showLoading,
+                    onReady: function () {
+                        hideLoading();
+                        retryCount = 0;
+                        playOverlay.style.display = 'none';
+                    },
+                    onError: function (msg) {
+                        if (retryCount < maxRetries) {
+                            retryCount++;
+                            showLoading(
+                                'Préparation du flux ' + retryCount + '/' + maxRetries
+                            );
+                            setTimeout(buildPlayer, 1500);
+                        } else {
+                            showError(msg);
+                        }
+                    },
+                    onBlocked: function () {
+                        hideLoading();
+                        playOverlay.style.display = 'flex';
+                    },
+                    onProfileChange: function (name) {
+                        // Retour visuel discret : l'utilisateur comprend pourquoi
+                        // la latence augmente légèrement après des coupures.
+                        loadingHint.textContent =
+                            name === 'safe' ? 'Réseau instable — buffer maximal'
+                                            : 'Réseau instable — buffer élargi';
+                    }
+                });
+
+                player.start();
+                window.xfPlayer = player;
+            }
 
             playOverlay.addEventListener('click', function () {
                 video.play();
                 playOverlay.style.display = 'none';
             });
 
-            player.start();
-            window.xfPlayer = player;
+            buildPlayer();
         })();
     </script>
 </body>

web/player_lite.html

@@ -5,7 +5,35 @@
     <meta charset="UTF-8">
     <title>XtremFlow Player Lite</title>
     <link rel="stylesheet" href="xf-player.css">
-    <link rel="preload" href="vendor/hls.min.js" as="script">
+    <script>
+        // Précharge la SEULE lib utile à CE flux, dès le parse du <head>.
+        // Un préchargement fixe de hls.js faisait télécharger 618 Ko inutiles
+        // à chaque zap TV — la lib réellement nécessaire au direct est
+        // mpegts.js — et cette bande passante était prise sur le flux
+        // lui-même et sur mpegts.js, jusqu'à faire échouer son chargement sur
+        // les liens contraints. Même décision que XFPlayer.start().
+        (function () {
+            var p = new URLSearchParams(location.search);
+            var url = (p.get('url') || '').toLowerCase();
+            var isHls = url.indexOf('.m3u8') !== -1;
+            var nativeHls =
+                document.createElement('video')
+                    .canPlayType('application/vnd.apple.mpegurl') !== '';
+            var lib = null;
+            if (isHls) {
+                // Safari/iOS lit le HLS nativement : aucune lib à charger.
+                if (!nativeHls) lib = 'hls.min.js';
+            } else if (p.get('type') === 'live' || url.indexOf('.ts') !== -1) {
+                lib = 'mpegts.min.js';
+            }
+            if (!lib) return;
+            var l = document.createElement('link');
+            l.rel = 'preload';
+            l.as = 'script';
+            l.href = 'vendor/' + lib;
+            document.head.appendChild(l);
+        })();
+    </script>
 </head>
 
 <body>

web/player_mobile.html

@@ -8,7 +8,35 @@
     <meta name="apple-mobile-web-app-capable" content="yes">
     <title>XtremFlow Player Mobile</title>
     <link rel="stylesheet" href="xf-player.css">
-    <link rel="preload" href="vendor/hls.min.js" as="script">
+    <script>
+        // Précharge la SEULE lib utile à CE flux, dès le parse du <head>.
+        // Un préchargement fixe de hls.js faisait télécharger 618 Ko inutiles
+        // à chaque zap TV — la lib réellement nécessaire au direct est
+        // mpegts.js — et cette bande passante était prise sur le flux
+        // lui-même et sur mpegts.js, jusqu'à faire échouer son chargement sur
+        // les liens contraints. Même décision que XFPlayer.start().
+        (function () {
+            var p = new URLSearchParams(location.search);
+            var url = (p.get('url') || '').toLowerCase();
+            var isHls = url.indexOf('.m3u8') !== -1;
+            var nativeHls =
+                document.createElement('video')
+                    .canPlayType('application/vnd.apple.mpegurl') !== '';
+            var lib = null;
+            if (isHls) {
+                // Safari/iOS lit le HLS nativement : aucune lib à charger.
+                if (!nativeHls) lib = 'hls.min.js';
+            } else if (p.get('type') === 'live' || url.indexOf('.ts') !== -1) {
+                lib = 'mpegts.min.js';
+            }
+            if (!lib) return;
+            var l = document.createElement('link');
+            l.rel = 'preload';
+            l.as = 'script';
+            l.href = 'vendor/' + lib;
+            document.head.appendChild(l);
+        })();
+    </script>
 </head>
 
 <body>

web/xf-player-core.js

@@ -60,17 +60,67 @@
   // ------------------------------------------------------------------
   var _scriptCache = {};
 
-  function loadScript(src) {
-    if (_scriptCache[src]) return _scriptCache[src];
-    _scriptCache[src] = new Promise(function (resolve, reject) {
+  function _delay(ms) {
+    return new Promise(function (resolve) { setTimeout(resolve, ms); });
+  }
+
+  function _injectScript(src) {
+    return new Promise(function (resolve, reject) {
       var s = document.createElement('script');
       s.src = src;
       s.async = true;
-      s.onload = resolve;
-      s.onerror = function () { reject(new Error('Échec du chargement : ' + src)); };
+      s.onload = function () { resolve(); };
+      s.onerror = function () {
+        // Laisser une balise morte dans le <head> ferait échouer une
+        // éventuelle nouvelle tentative sur le même src.
+        if (s.parentNode) s.parentNode.removeChild(s);
+        reject(new Error('script error'));
+      };
       document.head.appendChild(s);
     });
-    return _scriptCache[src];
+  }
+
+  /**
+   * Précise la cause d'un échec pour le message affiché et les logs :
+   * 404 = lib absente de l'image déployée, 429 = quota du rate limiter,
+   * échec réseau = lien coupé. Sans cela, toutes les causes se
+   * ressemblaient à l'écran.
+   */
+  function _describeFailure(src) {
+    if (typeof fetch !== 'function') return Promise.resolve('');
+    return fetch(src, { credentials: 'same-origin', cache: 'no-store' })
+      .then(function (r) { return r.ok ? '' : ' (HTTP ' + r.status + ')'; })
+      .catch(function () { return ' (réseau injoignable)'; });
+  }
+
+  /**
+   * Charge une lib vendorisée, avec une seconde tentative qui contourne le
+   * cache HTTP : les libs sont servies en `max-age=86400`, donc une entrée
+   * tronquée par une coupure réseau condamnait le lecteur jusqu'au vidage
+   * manuel du cache navigateur. Seuls les succès sont mémorisés — une
+   * promesse rejetée gardée en cache rendait tout réessai impossible pour
+   * le reste de la session.
+   */
+  function loadScript(src) {
+    if (_scriptCache[src]) return _scriptCache[src];
+
+    var attempt = _injectScript(src)
+      .catch(function () {
+        return _delay(400).then(function () {
+          return _injectScript(
+            src + (src.indexOf('?') === -1 ? '?' : '&') + 'reload=' + Date.now()
+          );
+        });
+      })
+      .catch(function () {
+        return _describeFailure(src).then(function (why) {
+          throw new Error('Échec du chargement : ' + src + why);
+        });
+      });
+
+    _scriptCache[src] = attempt;
+    attempt.catch(function () { delete _scriptCache[src]; });
+    return attempt;
   }
 
   /** Ouvre la connexion vers l'hôte du flux avant même de connaître l'URL finale. */
@@ -111,6 +161,13 @@
     this.injectedDuration = parseFloat(p.get('duration') || '0');
     this.isRecording = p.get('is_recording') === 'true';
 
+    // Décalage du média par rapport au début du contenu. Un enregistrement
+    // ouvert à 45 min est transcodé par FFmpeg *depuis* 45 min : le média
+    // commence à 0 alors que la lecture, elle, est à 2700 s. Tout ce qui
+    // sort du lecteur (position, recherche) est exprimé en temps absolu.
+    this.mediaOffset = parseFloat(p.get('offset') || '0');
+    if (!isFinite(this.mediaOffset) || this.mediaOffset < 0) this.mediaOffset = 0;
+
     // Profil de départ : forçable via ?buffer=balanced|safe
     var forced = p.get('buffer');
     this.profile = PROFILES[forced] ? PROFILES[forced] : PROFILES.fast;
@@ -124,8 +181,19 @@
     this._destroyed = false;
     this._reportedTime = 0;
     this._hlsDuration = 0;
+
+    // Écouteurs posés par cette instance, retirés à la destruction : sans
+    // ç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 = [];
   }
 
+  /** addEventListener + mémorisation pour un retrait propre. */
+  XFPlayer.prototype._on = function (target, type, handler, options) {
+    target.addEventListener(type, handler, options);
+    this._listeners.push({ target: target, type: type, handler: handler });
+  };
+
   XFPlayer.prototype.log = function (m) {
     if (global.console && console.log) console.log(this.logPrefix + ' ' + m);
   };
@@ -174,6 +242,8 @@
 
   XFPlayer.prototype._hlsConfig = function () {
     var prof = this.profile.hls;
+    var isLive = this.type === 'live';
+
     return {
       enableWorker: true,
       lowLatencyMode: false,
@@ -191,15 +261,39 @@
       startFragPrefetch: true,   // précharge le 1er fragment pendant le parse
       testBandwidth: false,      // pas de mesure préalable : on joue tout de suite
 
+      // ---- Début de lecture ----
+      // Un enregistrement (ou un film) est transcodé au fil de l'eau : sa
+      // playlist n'a pas encore d'`EXT-X-ENDLIST`, donc hls.js la considère
+      // comme du direct. Sans consigne explicite il démarre alors au « bord
+      // du direct », c'est-à-dire collé au front d'encodage : la lecture
+      // partait au milieu du programme et se coupait aussitôt, faute de
+      // segments d'avance. `0` = au début, comme attendu d'un contenu
+      // à la demande. En direct, -1 conserve le démarrage au bord du direct.
+      startPosition: isLive ? -1 : (this.startTime > 0 ? this.startTime : 0),
+
       // ---- Live ----
       liveSyncDurationCount: prof.liveSyncDurationCount,
-      liveMaxLatencyDurationCount: prof.liveMaxLatencyDurationCount,
-      maxLiveSyncPlaybackRate: 1.15,
+      // Hors direct, ces deux réglages doivent être neutralisés : ils
+      // accélèrent la lecture et finissent par forcer un saut en avant pour
+      // « rattraper » un direct qui n'existe pas.
+      // 86400 segments = hors d'atteinte, sans recourir à Infinity dont
+      // hls.js fait ensuite des multiplications.
+      liveMaxLatencyDurationCount: isLive
+        ? prof.liveMaxLatencyDurationCount
+        : 86400,
+      maxLiveSyncPlaybackRate: isLive ? 1.15 : 1,
 
       // ---- Robustesse ----
       nudgeOffset: 0.6,
       nudgeMaxRetries: 20,
       abrEwmaDefaultEstimate: 2000000,
+      // Hors direct, la première requête de playlist peut légitimement
+      // bloquer le temps que FFmpeg démarre et produise ses premiers
+      // segments. Le défaut de 10 s de hls.js transformait ce démarrage en
+      // « erreur de chargement » — il fallait relancer la lecture pour
+      // tomber sur une session déjà chaude.
+      manifestLoadingTimeOut: isLive ? 10000 : 45000,
+      levelLoadingTimeOut: isLive ? 10000 : 45000,
       manifestLoadingRetryDelay: 500,
       levelLoadingRetryDelay: 500,
       fragLoadingRetryDelay: 500,
@@ -253,6 +347,11 @@
         }
       });
     }).catch(function (err) {
+      // hls.js indisponible : plutôt que d'échouer, tenter les chemins qui
+      // ne demandent aucune lib (HLS natif Safari/iOS, sinon lecture directe
+      // si le navigateur sait décoder le conteneur).
+      self.log(err.message);
+      if (self._canPlayNativeHls()) { self._playDirect(self.url); return; }
       self.onError(err.message);
     });
   };
@@ -267,6 +366,24 @@
       }
       self._createMpegts(isLive);
     }).catch(function (err) {
+      // mpegts.js indisponible (build incomplet, coupure réseau, quota du
+      // rate limiter…) : le même flux reste lisible par la route HLS, où
+      // FFmpeg réencode déjà l'audio en AAC. Une seconde de latence en plus
+      // vaut mieux qu'un écran d'erreur sur une chaîne parfaitement lisible.
+      var hlsUrl = self._hlsEquivalent(self.url);
+      self.log(err.message + (hlsUrl ? ' — bascule sur le chemin HLS' : ''));
+      if (hlsUrl) {
+        self.url = hlsUrl;
+        self.onLoading('Ouverture du flux');
+        if (self._canPlayNativeHls()) { self._playDirect(hlsUrl); return; }
+        return self._startHls();
+      }
+      // Aucun équivalent HLS (flux direct fourni par la playlist) : dernier
+      // recours, laisser le navigateur décoder lui-même le conteneur.
+      if (self.video.canPlayType('video/mp2t') !== '') {
+        self._playDirect(self.url);
+        return;
+      }
       self.onError(err.message);
     });
   };
@@ -440,40 +557,94 @@
     var self = this;
     var v = this.video;
 
-    v.addEventListener('loadedmetadata', function () {
+    this._on(v, 'loadedmetadata', function () {
       if (self.startTime > 0 && self.startTime < v.duration) {
         v.currentTime = self.startTime;
       }
     });
 
-    v.addEventListener('playing', function () {
+    this._on(v, 'playing', function () {
       self._started = true;
       self.onReady();
       self.send({ type: 'playback_status', status: 'playing' });
     });
 
-    v.addEventListener('pause', function () {
+    this._on(v, 'pause', function () {
       self.send({ type: 'playback_status', status: 'paused' });
     });
 
-    v.addEventListener('waiting', function () { self._noteStall(); });
-    v.addEventListener('stalled', function () { self._noteStall(); });
+    this._on(v, 'waiting', function () { self._noteStall(); });
+    this._on(v, 'stalled', function () { self._noteStall(); });
 
-    v.addEventListener('ended', function () {
+    this._on(v, 'ended', function () {
       self.send({
         type: 'playback_ended',
-        duration: isFinite(v.duration) ? v.duration : self.injectedDuration
+        duration: self._totalDuration()
       });
     });
 
+    // Le front de transcodage avance : le parent doit pouvoir griser la
+    // portion pas encore navigable de la barre de progression. `progress`
+    // se déclenche à chaque bloc reçu — bridé à 2 s, sinon chaque segment
+    // provoquerait une reconstruction de l'interface Flutter.
+    this._on(v, 'progress', function () {
+      if (!self._started) return;
+      var now = Date.now();
+      if (now - (self._lastProgressSent || 0) < 2000) return;
+      self._lastProgressSent = now;
+      self._sendPosition();
+    });
+
+    this._on(v, 'seeked', function () { self._sendPosition(); });
+
     // Remontée de position (5 s) — même contrat qu'avant.
     this._posTimer = setInterval(function () { self._reportPosition(); }, 5000);
 
     // Activité utilisateur → masquage auto des contrôles côté Flutter.
     function activity() { self.send({ type: 'user_activity' }); }
-    document.addEventListener('mousemove', activity, { passive: true });
-    document.addEventListener('touchstart', activity, { passive: true });
-    document.addEventListener('click', activity, { passive: true });
+    this._on(document, 'mousemove', activity, { passive: true });
+    this._on(document, 'touchstart', activity, { passive: true });
+    this._on(document, 'click', activity, { passive: true });
+  };
+
+  /** Fin de la plage réellement navigable, en temps média. */
+  XFPlayer.prototype._seekableEnd = function () {
+    var v = this.video;
+    try {
+      if (v.seekable && v.seekable.length > 0) {
+        return v.seekable.end(v.seekable.length - 1);
+      }
+    } catch (e) {}
+    try {
+      if (v.buffered && v.buffered.length > 0) {
+        return v.buffered.end(v.buffered.length - 1);
+      }
+    } catch (e) {}
+    return isFinite(v.duration) ? v.duration : 0;
+  };
+
+  /** Durée totale du contenu (et non du seul média chargé), en secondes. */
+  XFPlayer.prototype._totalDuration = function () {
+    var v = this.video;
+    var duration = v.duration;
+    var hlsDur = this._hlsDuration || 0;
+    if (!isFinite(duration) || isNaN(duration) || duration < 1) {
+      duration = hlsDur;
+    } else if (hlsDur > duration) {
+      duration = hlsDur;
+    }
+
+    // Temps absolu : le média peut commencer après le début du contenu.
+    var total = duration > 0 ? this.mediaOffset + duration : 0;
+
+    // La durée annoncée par l'app fait foi tant que le média n'en connaît
+    // qu'une fraction — cas d'une playlist `event` encore en cours de
+    // transcodage, où la durée grandirait sous la barre de progression.
+    // Au-delà, le média a raison : les métadonnées Xtream sont approximatives.
+    if (this.injectedDuration > 0 && total < this.injectedDuration * 0.98) {
+      return this.injectedDuration;
+    }
+    return total;
   };
 
   XFPlayer.prototype._reportPosition = function () {
@@ -481,27 +652,60 @@
     if (!(v.currentTime > 0) || v.paused || v.readyState <= 2) return;
     if (Math.abs(v.currentTime - this._reportedTime) < 1) return;
     this._reportedTime = v.currentTime;
+    this._sendPosition();
+  };
 
-    var duration = v.duration;
-    var hlsDur = this._hlsDuration || 0;
-    if (!isFinite(duration) || isNaN(duration) || duration < 1) {
-      duration = hlsDur > 0 ? hlsDur : (this.injectedDuration > 0 ? this.injectedDuration : 0);
-    } else if (hlsDur > duration) {
-      duration = hlsDur;
-    } else if (this.injectedDuration > 0 && duration < this.injectedDuration * 0.9) {
-      duration = this.injectedDuration;
-    }
-
+  /** Envoi immédiat de l'état de lecture (position, durée, zone navigable). */
+  XFPlayer.prototype._sendPosition = function () {
     this.send({
       type: 'playback_position',
-      currentTime: v.currentTime,
-      duration: duration
+      currentTime: this.mediaOffset + this.video.currentTime,
+      duration: this._totalDuration(),
+      seekableEnd: this.mediaOffset + this._seekableEnd()
     });
   };
 
+  /**
+   * Recherche à un instant ABSOLU du contenu.
+   *
+   * Tant que la cible est dans la zone déjà transcodée, c'est une simple
+   * affectation de `currentTime`. Au-delà, aucune quantité d'attente ne la
+   * rendra disponible rapidement : le parent est prévenu pour relancer le
+   * flux à cet instant (nouvelle session FFmpeg `?start=`).
+   */
+  XFPlayer.prototype.seekTo = function (absolute) {
+    if (!isFinite(absolute)) return;
+    var v = this.video;
+    var target = absolute - this.mediaOffset;
+    var end = this._seekableEnd();
+
+    if (target < 0) {
+      // Avant le début du média chargé : cette portion n'est pas dans cette
+      // session de transcodage, il faut en relancer une plus tôt.
+      this.send({ type: 'seek_out_of_range', value: Math.max(0, absolute) });
+      return;
+    }
+
+    // Marge de 10 s : juste devant le front de transcodage, attendre coûte
+    // moins cher que relancer un encodeur.
+    if (end > 0 && target > end + 10) {
+      this.send({ type: 'seek_out_of_range', value: absolute });
+      return;
+    }
+
+    try {
+      v.currentTime = end > 0 ? Math.min(target, Math.max(0, end - 0.5)) : target;
+    } catch (e) {
+      this.send({ type: 'seek_out_of_range', value: absolute });
+      return;
+    }
+    this._reportedTime = v.currentTime;
+    this._sendPosition();
+  };
+
   XFPlayer.prototype._wireParentMessages = function () {
     var self = this;
-    global.addEventListener('message', function (event) {
+    this._on(global, 'message', function (event) {
       // N'accepter que les commandes émises par notre propre origine
       // (le côté Flutter filtre déjà les messages entrants de la même façon).
       if (event.origin !== global.location.origin) return;
@@ -516,7 +720,12 @@
           v.pause();
           break;
         case 'seek':
-          if (isFinite(d.value)) v.currentTime = d.value;
+          self.seekTo(d.value);
+          break;
+        case 'set_rate':
+          if (isFinite(d.value) && d.value > 0) {
+            try { v.playbackRate = Math.max(0.25, Math.min(4, d.value)); } catch (e) {}
+          }
           break;
         case 'set_volume':
           v.volume = Math.max(0, Math.min(1, d.value));
@@ -533,6 +742,10 @@
   XFPlayer.prototype.destroy = function () {
     this._destroyed = true;
     clearInterval(this._posTimer);
+    this._listeners.forEach(function (l) {
+      try { l.target.removeEventListener(l.type, l.handler); } catch (e) {}
+    });
+    this._listeners = [];
     try { if (this.hls) this.hls.destroy(); } catch (e) {}
     try {
       if (this.mpegts) {