Merge pull request 'push-zpoknxvwspkr' (#96) from push-zpoknxvwspkr into main

Reviewed-on: #96

.cargo/config.toml

@@ -0,0 +1,2 @@
+[registries]
+pmo = { index = "sparse+https://gargoton.petite-maison-orange.fr/api/packages/pmo/cargo/" }

.claude/CLAUDE.md

@@ -1,31 +0,0 @@
-# PMOMusic Project Configuration
-
-## Version Control
-Ce projet utilise **Jujutsu (jj)** pour le contrôle de version, PAS git.
-- Utiliser les commandes `jj` au lieu des commandes `git`
-- Bookmark principal : `main`
-- Ne jamais suggérer de commandes git
-
-## Environnement
-Le PATH et les variables d'environnement sont configurés dans `.claude-env` à la racine du projet.
-
-## Configuration de l'application
-- Fichier de configuration principal : `.pmomusic/config.yaml`
-- Configuration UPNP personnalisable pour différencier les instances en développement
-
-## Développement
-Pendant le développement, plusieurs serveurs PMOMusic peuvent tourner en parallèle. Utiliser la configuration UPNP dans `.pmomusic/config.yaml` pour différencier les instances :
-
-```yaml
-host:
-  upnp:
-    manufacturer: "PMOMusic-Dev1"
-    udn_prefix: "pmomusic-dev1"
-    model_name_prefix: "PMOMusic-Dev1"
-    friendly_name_prefix: "PMOMusic-Dev1"
-```
-
-## Architecture
-- Projet Rust multi-crates avec workspaces
-- Crates principales : pmoupnp, pmomediaserver, pmomediarenderer, pmoconfig
-- Pattern d'extension de configuration via traits (voir pmocache/src/config_ext.rs)

.gitea/workflows/build-push.yaml

@@ -3,8 +3,7 @@ name: Build and Push Docker Image
 on:
   push:
     branches:
-      - main  # Changez cela si votre branche principale a un autre nom
-    
+      - main # Changez cela si votre branche principale a un autre nom
 
 jobs:
   build:
@@ -15,7 +14,7 @@ jobs:
         uses: actions/cache@v3
         with:
           path: ~/.npm
-          key: dont-cache-${{ github.run_id }}        
+          key: dont-cache-${{ github.run_id }}
       - name: Build and push image
         uses: https://gargoton.petite-maison-orange.fr/pmo-actions/build-push-image@main
         with:
@@ -24,6 +23,3 @@ jobs:
           no_cache: true
           version_file: version.txt
           check_uuid: 82a30d23-b3bd-4199-9237-776965831d20
-
-
-  

.gitignore

@@ -8,7 +8,7 @@
 **/*.o
 **/*.o.d
 **/*.a
-**/*.flac 
+**/*.flac
 **/*.aif
 **/*.aiff
 **/*.wav
@@ -16,19 +16,22 @@
 **/*.mp4
 **/*.mp3
 **/*.ogg
+
 xxx
 /dcai/
 **/.pmomusic.yml
 **/.pmomusic_covers/**
 **/.pmomusic_audio/**
 /.pmomusic
-.DS_Store
-target
+**/.DS_Store
+/target
+**/target/
 /.pmomusic_covers
-/.pmomusic_audio/** 
+/.pmomusic_audio/**
 C/src/soxr-0.1.3/Release/tests
 **/Release/
 **/Debug/
+qobuz_debug
 OLD-GO-CODE/
 xxx
 xx
@@ -37,9 +40,13 @@ pmo_src.txt
 upmpdcli/
 /*.xml
 test_upnp*.cargo/
-.cargo/
 setup-env.sh
 cache
 gupnp-tools
 pmo*_[0_9]*.txt
-webapp_[0_9]*.txt
+webapp_[0_9]*.txt
+RF.json
+RF_old.json
+.claude/
+.claude.old
+Kilo-session.md

.kilo/plans/1775285337131-neon-mountain.md

@@ -0,0 +1,405 @@
+# Évaluation du plan : centraliser_base_url_axum_middleware
+
+## Résumé de l'audit
+
+Le plan est **bien pensé et cohérent**. Il identifie correctement le problème et la solution. Cependant, j'ai identifié plusieurs points nécessitant des amendements.
+
+---
+
+## Points validés (conformes au code actuel)
+
+1. **Problème bien identifié** : URLs hardcodées avec IP locale (`PMO_SERVER_URL`) retournées au frontend via reverse proxy.
+
+2. **`get_request_base_url` existe déjà** à `pmoserver/src/lib.rs:199` — pas besoin de la recréer.
+
+3. **`covers_route_for` existe déjà** dans `pmocache/src/lib.rs:149`.
+
+4. **`covers_absolute_url_for` utilisée dans les contextes UPnP** :
+   - `pmoupnp/src/cache_registry.rs:57`
+   - `pmoradiofrance/src/metadata_cache.rs:263`
+   - `pmoparadise/src/source.rs:216`
+   - `pmoaudio-ext/src/sinks/streaming_icyflac_sink.rs:91`
+
+5. **Route audio correcte** : `/audio/tracks/{pk}` (pas `/audio/flac/{pk}`).
+
+6. **Architecture du Server** : Les routes sont construites dynamiquement via `Arc<RwLock<Router>>`. Le layer devra être ajouté dans la construction du router, pas après.
+
+---
+
+## Points à amender
+
+### 1. Ajout du layer dans le Server
+
+Le plan suggère d'ajouter le layer "dans `server.rs`" mais la structure du router est complexe :
+- Les routes sont dynamiques (`RwLock<Router>`)
+- Le router final est un fallback qui délègue
+
+**Correction** : Ajouter le layer directement lors de la création du `registry_route` initial (ligne 120-122) :
+
+```rust
+let registry_route = Router::new()
+    .route("/api/registry", get(get_api_registry))
+    .with_state(api_registry.clone())
+    .layer(base_url_layer());  // ← ici
+```
+
+### 2. Comportement requis pour LAN vs WAN
+
+Le middleware doit supporter les deux cas d'usage :
+
+- **LAN (sans reverse proxy)** : Pas de headers `X-Forwarded-*` → utiliser l'adresse IP locale du serveur (`PMO_SERVER_URL`)
+- **WAN (via reverse proxy)** : Headers `X-Forwarded-*` présents → utiliser l'URL publique du reverse proxy
+
+**Important** : `get_request_base_url` dans `pmoserver/src/lib.rs:199` lit déjà ces headers. Le fallback doit être `PMO_SERVER_URL` qui est configuré au démarrage avec l'IP locale.
+
+### 3. Chemin du middleware dans la pile
+
+Le plan dit d'appliquer le layer "avant" les autres. En réalité, Tower/Acorn applique les couches dans l'ordre où elles sont ajoutées — le premier layer ajouté est le plus extérieur (exécuté en premier). Le `base_url_layer` doit donc être ajouté en **premier** (le plus intérieur) pour voir les headers nettoyés.
+
+### 3. Les handlers n'ont PAS besoin de BaseUrl
+
+Après analyse, **aucun handler** dans le codebase actuel n'appelle `covers_absolute_url_for()` directement pour le frontend. Les `album_art_uri` sont :
+- Soit **propagés** depuis les réponses UPnP des media servers (pas des URLs pmomusic)
+- Soit **construits en tâche de fond** dans les caches (RadioFrance, RadioParadise)
+
+**Correction** : Le plan surestime le nombre de handlers à modifier. La vraie question est : d'où viennent les URLs incorrectes ?
+
+### 4. Source du problème à clarifier
+
+Les URLs incorrectes ne viennent pas des handlers REST classiques. Elles viennent probablement de :
+
+**a) Tâches de fond** (background tasks) qui stockent des URLs complètes :
+- `pmoradiofrance/src/metadata_cache.rs:263` — construit `covers_absolute_url_for()` dans le cache
+- `pmoparadise/src/source.rs:216` — même problème
+
+**b) API Qobuz** (`pmoqobuz/src/api_rest.rs:302`) — utilise `covers_route_for` (route relative, OK)
+
+**c) Playlist** (`pmoplaylist/src/handle/read.rs:204,271,355`) — utilise `covers_route_for` (OK)
+
+### 5. Correction du fallback
+
+Le plan suggère `localhost:8080` ou `0.0.0.0:8080` comme fallback. Le port doit provenir de la configuration du serveur (`get_server_base_url()` existe déjà dans `pmoserver/src/lib.rs`).
+
+**Correction** : Le fallback utilise `get_server_base_url()` (disponible via `GLOBAL_SERVER`) :
+- En LAN : pas de `X-Forwarded-*` → `get_server_base_url()` → URLs en IP locale
+- En WAN : `X-Forwarded-*` présents → URLs en URL publique du reverse proxy
+
+### 6. Fonction `audio_route_for` pas nécessaire maintenant
+
+Le plan propose d'ajouter `audio_route_for` dans `pmoaudiocache`. Mais :
+- Les fichiers audio sont servis par `pmoaudiocache` lui-même (routes internes)
+-Aucune URL audio n'est retournée au frontend via JSON
+
+**Supprimer** cette étape du plan.
+
+---
+
+## Plan amendé
+
+### Étape 0 — Audit spécifique (à faire avant implémentation)
+
+```bash
+# Trouver les constructions d'URLs dans les tâches de fond (caches, sources)
+grep -rn "covers_absolute_url_for\|PMO_SERVER_URL" --include="*.rs" | grep -v "pmocontrol\|pmoplaylist\|pmoqobuz"
+
+# Vérifier les URLs dans les réponses JSON des handlers
+grep -rn "album_art_uri" --include="*.rs" | grep -E "fn |->"
+```
+
+Identifier spécifiquement quels endpoints REST retournent des URLs au frontend.
+
+### Étape 1 — `pmoserver/src/lib.rs` : Ajouter `BaseUrl` + middleware
+
+```rust
+use axum::{extract::Request, middleware::Next, response::Response};
+
+#[derive(Debug, Clone)]
+pub struct BaseUrl(pub String);
+
+impl BaseUrl {
+    pub fn url_for(&self, route: &str) -> String {
+        debug_assert!(route.starts_with('/'), "route must start with '/'");
+        format!("{}{}", self.0.trim_end_matches('/'), route)
+    }
+}
+
+pub async fn base_url_middleware(mut request: Request, next: Next) -> Response {
+    // Priorité : 1) X-Forwarded-* (reverse proxy), 2) get_server_base_url() (adresse configurée)
+    let base = get_request_base_url(request.headers())
+        .or_else(|| get_server_base_url())
+        .unwrap_or_else(|| {
+            panic!(
+                "BaseUrl: impossible de déterminer l'URL de base.\n\
+                Configurer PMO_SERVER_URL ou démarrer le serveur avant les handlers HTTP."
+            );
+        });
+    tracing::debug!("BaseUrl calculée : {}", base);
+    request.extensions_mut().insert(BaseUrl(base));
+    next.run(request).await
+}
+
+pub fn base_url_layer() -> axum::middleware::FromFnLayer {
+    axum::middleware::from_fn(base_url_middleware)
+}
+```
+
+**Comportement** :
+- Accès LAN (pas de proxy) : `get_server_base_url()` → URLs en IP locale configurée
+- Accès WAN (reverse proxy) : `X-Forwarded-*` → URLs en URL publique
+
+**Note** : Si ni les headers ni le serveur ne sont disponibles, le middleware panic (fail-fast) car c'est une erreur de configuration.
+
+### Étape 2 — `pmoserver/src/server.rs` : Appliquer le layer
+
+Dans `Server::new()`, ligne ~120-122 :
+
+```rust
+let registry_route = Router::new()
+    .route("/api/registry", get(get_api_registry))
+    .with_state(api_registry.clone())
+    .layer(base_url_layer());  // ← Ajouter ici (couche la plus intérieure)
+```
+
+### Étape 3 — `pmocache/src/lib.rs` : Renommer sans déprecation
+
+```rust
+// Rename direct - pas de déprecation (soft en cours de dev, pas une library)
+pub fn covers_absolute_url_for_upnp(pk: &str, param: Option<&str>) -> String {
+    // PMO_SERVER_URL contient l'IP locale (LAN) - utilisé uniquement pour UPnP
+    // Fallback sur get_server_base_url() si dispo, sinon erreur
+    let base = std::env::var("PMO_SERVER_URL")
+        .or_else(|_| pmoserver::get_server_base_url().ok_or("PMO_SERVER_URL not set"))
+        .unwrap_or_else(|e| {
+            tracing::error!("covers_absolute_url_for_upnp: {}", e);
+            panic!("BaseUrl non disponible pour UPnP");
+        });
+    format!("{}{}", base.trim_end_matches('/'), covers_route_for(pk, param))
+}
+```
+
+### Étape 4 — Mettre à jour les appels UPnP
+
+```bash
+grep -rn "covers_absolute_url_for" --include="*.rs"
+```
+
+Modifier `pmoupnp/src/cache_registry.rs:57` → `covers_absolute_url_for_upnp`
+
+### Étape 5 — Tâches de fond : stocker la route, pas l'URL
+
+**pmoradiofrance/src/metadata_cache.rs:263** :
+```rust
+// Avant :
+let public_url = pmocache::covers_absolute_url_for(&pk, None);
+
+// Après : stocker la route relative
+let album_art_route = pmocache::covers_route_for(&pk, None);
+```
+
+Le handler REST qui retourne ces métadonnées devra extraire `Extension<BaseUrl>` et appliquer `base_url.url_for()`.
+
+**pmoparadise/src/source.rs:216** : Même traitement.
+
+### Étape 6 — Vérification et tests
+
+```bash
+# Plus d'appels à covers_absolute_url_for dans les contextes HTTP
+grep -rn "covers_absolute_url_for" --include="*.rs" | grep -v "pmocache\|pmoupnp"
+
+# Tests du middleware
+cargo test base_url
+```
+
+---
+
+## Questions en suspens
+
+1. **Fallback avec panic** : Si ni les headers ni le serveur ne sont disponibles, le middleware panic au démarrage avec un message clair (ex: "BaseUrl: configurer PMO_SERVER_URL ou démarrer le serveur avant les handlers HTTP").
+   → **Décision utilisateur** : OK, panic avec message clair.
+
+2. **Reverse proxy avec Authelia** : NPM ajoutera les headers `X-Forwarded-*`. Authelia gère l'authentification separately. Pas de vérification de header supplémentaire nécessaire pour le middleware BaseUrl.
+   → **Décision** : Pas de vérification supplémentaire.
+
+---
+
+## Problème complémentaire : URLs de covers des media servers externes
+
+### Contexte
+
+Quand le control point accède à un media server externe sur le LAN (autre que pmomusic), les URLs d'articles (`album_art_uri`) retournées par ce media server externe contiennent des IPs locales du LAN externe (ex: `http://192.168.1.100:8080/covers/...`).
+
+Ces URLs ne passent pas par notre système de caching et ne peuvent pas être rewritées par le middleware `BaseUrl` car elles sont :
+1. Recues depuis le réseau UPnP (pas via HTTP)
+2. Propagées directement dans les réponses REST/SSE sans transformation
+
+### Solution proposée : Proxy de covers avec cache
+
+Créer un nouveau endpoint HTTP qui agit comme un proxy transparent :
+1. **Détection** : Si l'URL demandée est une URL LAN externe (pas une URL locale de pmomusic)
+2. **Caching** : Utiliser `cache.add_from_url()` qui gère déjà la déduplication (pas de double-cache)
+3. **Rewriting** : Retourner l'URL locale du cache (`/covers/image/{pk}`)
+
+**Note importante** : `pmocache::add_from_url()` gère déjà :
+- La vérification si l'URL est déjà en cache (ligne 673-683)
+- Le calcul du pk basé sur le contenu (pas sur l'URL)
+- La déduplication automatique pour les mêmes contenus
+
+### Implémentation
+
+**Nouvel endpoint dans `pmocovers/src/lib.rs` ou nouveau fichier `pmocovers/src/proxy.rs`** :
+
+```rust
+#[derive(Debug, Deserialize)]
+struct CoverProxyParams {
+    url: String,
+}
+
+#[derive(Debug, Serialize)]
+struct CoverProxyResponse {
+    cached_url: String,
+    pk: String,
+}
+
+/// GET /covers/proxy?url=<encoded_url>
+/// Proxy transparent qui :
+/// 1. Détecte si l'URL est une URL LAN externe (pas déjà locale)
+/// 2. Ajoute à cache via add_from_url (déduplication automatique)
+/// 3. Retourne l'URL locale du cache
+pub async fn cover_proxy_handler(
+    Query(params): Query<CoverProxyParams>,
+    State(cache): State<CoverCache>,
+    Extension(base_url): Extension<pmoserver::BaseUrl>,
+) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let external_url = &params.url;
+    
+    // Ignorer si déjà une URL locale (ne pas se cacher soi-même)
+    if is_local_cover_url(external_url, &base_url) {
+        return Err((StatusCode::BAD_REQUEST, "URL is already a local cover"));
+    }
+    
+    // Vérifier si c'est une URL LAN à proxyfier
+    if !should_proxy_url(external_url) {
+        return Err((StatusCode::BAD_REQUEST, "URL is not a LAN URL requiring proxy"));
+    }
+    
+    // Ajouter au cache (add_from_url gère la déduplication)
+    let pk = cache.add_from_url(external_url, Some("external-covers"))
+        .await
+        .map_err(|e| (StatusCode::BAD_GATEWAY, e.to_string()))?;
+    
+    // Retourner l'URL locale
+    let local_url = base_url.url_for(&pmocache::covers_route_for(&pk, None));
+    Ok(Json(CoverProxyResponse { cached_url: local_url, pk }))
+}
+
+/// Vérifie si l'URL est déjà une cover locale de NOTRE instance pmomusic
+/// Note: Les covers d'autres instances pmomusic sur le LAN DEVRAIENT être proxyfiées
+///       et mises en cache localement - c'est le comportement desired!
+fn is_local_cover_url(url: &str, base_url: &pmoserver::BaseUrl) -> bool {
+    // Only skip if it's OUR instance's base URL
+    // Covers from other pmomusic instances on LAN should be proxied and cached
+    url.starts_with(&base_url.0)
+}
+
+/// Vérifie si l'URL doit être proxyfiée (URL LAN externe)
+fn should_proxy_url(url: &str) -> bool {
+    if let Ok(parsed) = url::Url::parse(url) {
+        if let Some(host) = parsed.host_str() {
+            // Proxy uniquement les URLs LAN (pas les URLs publiques)
+            if let Ok(ip) = host.parse::<std::net::IpAddr>() {
+                return ip.is_private() || ip.is_loopback();
+            }
+            // aussi les .local
+            return host.ends_with(".local") || host == "localhost";
+        }
+    }
+    false
+}
+```
+
+**Points importants** :
+- Utiliser `add_from_url()` pour bénéficier de la déduplication automatique
+- Vérifier `is_local_cover_url()` avec uniquement la comparaison de base_url pour éviter que notre instance ne se cache elle-même
+- Les covers d'autres instances pmomusic sur le LAN DEVRAIENT être proxyfiées (comportement souhaité!)
+- Le TTL sera celui par défaut du cache (configurable)
+
+**Mise à jour des handlers REST** :
+
+Dans `pmocontrol/src/pmoserver_ext.rs` et `pmocontrol/src/sse.rs`, transformer les `album_art_uri` LAN :
+
+```rust
+fn transform_external_cover_url(url: &str) -> String {
+    if is_lan_url(url) {
+        // Remplacer par l'URL du proxy
+        let encoded = urlencoding::encode(url);
+        return format!("/covers/proxy?url={}", encoded);
+    }
+    url.to_string()
+}
+```
+
+**Appels dans les handlers** :
+
+- `pmocontrol/src/pmoserver_ext.rs:2173` : `browse_container` → transformer `album_art_uri`
+- `pmocontrol/src/pmoserver_ext.rs:2424` : autre endpoint → même transformation
+- `pmocontrol/src/sse.rs:213` : `MetadataChanged` events → même transformation
+
+### TTL
+
+- Le TTL sera celui par défaut du cache `pmocovers`
+- C'est configurable via `pmoconfig` si besoin
+
+### Sécurité
+
+- Limiter aux URLs LAN uniquement (`192.168.x.x`, `10.x.x.x`, `172.16-31.x.x`, `localhost`)
+- Vérifier que l'URL n'est pas déjà une cover locale de pmomusic (éviter le cacheception)
+- Ajouter un rate limiting pour éviter le flood de téléchargement
+- Timeout de téléchargement : 10 secondes max
+
+### Résumé des fichiers à modifier
+
+1. **Nouveau** : `pmocovers/src/proxy.rs` - Endpoint de proxy
+2. **Modifier** : `pmocontrol/src/pmoserver_ext.rs` - Transformer les album_art_uri
+3. **Modifier** : `pmocontrol/src/sse.rs` - Transformer les album_art_uri dans les événements
+
+---
+
+## Plan: Passer le SSE en mode Async
+
+### Contexte
+
+Le SSE de PMO Control est **déjà async** (fonctions `pub async fn`), mais le traitement des événements utilise des fonctions **synchrones** (`fn renderer_event_to_payload` → `transform_cover_url_sync`). Cela nécessite des workarounds (threads avec runtime tokio séparés).
+
+### Problèmes actuels
+
+1. **Nested runtime**: `std::thread::spawn` avec `tokio::runtime::Runtime::new()` dans chaque appel
+2. **Performance dégradée**: Création d'un thread par URL de cover
+3. **Code complexe**: Workarounds pour exécuter de l'async dans du sync
+
+### Solution
+
+Rendre le traitement des événements **entièrement async** :
+
+1. **Modifier** `renderer_event_to_payload` → `async fn renderer_event_to_payload`
+2. **Modifier** `transform_cover_url_sync` → `transform_cover_url` (async) avec `.await` direct
+3. **Supprimer** le workaround `proxy_cover_url_sync` dans `pmocovers` (quand les .await fonctionnent)
+
+### Avantages attendus
+
+1. **Fluidité accrue**: Pas de thread par cover,真正的 async/await
+2. **Meilleure réactivité**: Pas de blocking sur les événements SSE
+3. **Code plus propre**: Plus de workarounds, plus de runtime imbriqué
+4. **Meilleure scalabilité**: Plus de création de thread
+
+### Fichiers à modifier
+
+1. `pmocontrol/src/sse.rs`:
+   - `renderer_event_to_payload` → `async fn`
+   - `media_server_event_to_payload` → `async fn`
+   - `all_events_sse`: utiliser les versions async
+
+2. `pmocontrol/src/pmoserver_ext.rs`:
+   - Utiliser `transform_cover_url` (async) avec `.await` au lieu de `transform_cover_url_sync`
+
+3. `pmocontrol/src/control_point.rs` (si nécessaire):
+   - Adapter les appels aux fonctions async

.kilo/plans/1775302116634-sunny-nebula.md

@@ -0,0 +1,151 @@
+# Plan: pmowebrenderer - Améliorations et Multi-client avec DSP
+
+## Objectifs
+
+1. **Améliorer l'intégration UPnP Control** - Meilleur fonctionnement des commandes Play/Pause/Seek
+   - Contrôle piloté près de la sortie (streaming) plutôt qu'au début du pipeline
+   - Pour Pause: latence actuelle trop importante
+   - Play/Pause/Seek doivent fonctionner simultanément sur tous les clients
+
+2. **Améliorer la performance - Latence** - Réduire le délai entre l'envoi et la lecture
+
+3. **Ajouter le support multi-client avec DSP** - Chaque client peut avoir son propre pipeline DSP
+
+## Comportement UPnP Control
+
+### Mode Radio (flux infini)
+- Pas de pause possible, hanya next ou stop
+- Seek n'a pas de sens
+
+
+### Architecture
+```
+PlayerSource → ResamplingNode → ToI24Node
+                                           ├──→ [DSP Client 1] → StreamingOggFlacSink 1
+                                           ├──→ [DSP Client 2] → StreamingOggFlacSink 2
+                                           └──→ ... (dynamique)
+```
+
+Le control point UPnP voit UN seul Media Renderer. Les commandes Play/Pause/Seek affectent TOUTES les sorties client simultanément.
+
+## État Actuel
+
+Le pipeline actuel est linéaire pour un seul client:
+```
+PlayerSource → ResamplingNode (96kHz) → ToI24Node → StreamingOggFlacSink
+```
+
+**Note importante:** Utiliser les crates pmoaudio et pmoaudio-ext existantes. Il est possible d'avoir plusieurs `StreamingOggFlacSink` consommant le même flux. Après ToI24Node, brancher en étoiles les différents DSP pour les différents clients.
+
+## Plan d'Implémentation
+
+### Phase 1: Amélioration UPnP Control
+
+1. **Analyser les handlers existants** dans `handlers.rs`
+2. **Identifier les problèmes** avec Play/Pause/Seek:
+   - Timing des transitions d'état
+   - Gestion des erreurs
+   - Synchronisation entre clients HTTP et état UPnP
+3. **Améliorer la fiabilité** des commandes
+   - Piloter le contrôle près de la sortie (streaming)
+   - Différerencier le comportement radio vs piste finie
+
+### Phase 2: Amélioration Latence
+
+1. **Réduire le buffer** dans `StreamingOggFlacSink`
+2. **Optimiser le pacing** (actuellement max 0.5s ahead)
+3. **Améliorer la directité** du chemin audio
+
+### Phase 3: Architecture Multi-client avec DSP
+
+1. **Refactorer le pipeline** pour supporter plusieurs clients comme décrit ci-dessus
+
+2. **Créer un système de DSP** dans pmoaudio ou pmoaudio-ext:
+   - Interface commune pour les effets audio
+   - Config des DSP via PMOconfig
+   - Room correction: equalizer, FIR filter, delay, gain
+
+3. **Gérer le cycle de vie**:
+   - Création du pipeline par client
+   - Nettoyage lors de la déconnexion
+   - Partage de la source commune entre clients
+
+## Fichiers à Modifier
+
+- `pipeline.rs` - Refactoring pour multi-client
+- `handlers.rs` - Amélioration UPnP control
+- `stream.rs` - Gestion multi-client
+- `state.rs` - État par client
+- pmoaudio ou pmoaudio-ext pour les mécanismes DSP
+
+## Défis Potentiels
+
+- Performance CPU avec plusieurs clients
+- Synchronisation des clients avec le même contenu
+- Gestion du gapless entre les pistes avec multi-client
+
+### Gestion de la Pause
+
+**Option recommandée: Silence (zéros)**
+- Pendant la pause, continuer à envoyer des zéros encodés en FLAC
+- Le client HTTP maintient sa connexion TCP alive
+- Pas de reconnexion nécessaire quand on reprend la lecture
+- Avantage: Seamless pour le client
+
+**Pourquoi pas réduction du sample rate:**
+- Le header FLAC définit le sample rate en固定entête
+- Changer le sample rate en cours de flux invalidate le flux entier
+- Rebuild du flux serait plus complexe que le gain obtenu
+- FLAC compresse très bien les zéros de toute façon (beaucoup de répétitions)
+
+**Autre option envisagée mais non recommandée:**
+- Suspendre l'envoi: Le client HTTP va timeout et se déconnecter
+- Segment OGG avec metadata: Complexe à implémenter, nécessite modification du client
+
+### Phase 0: StreamingOggFlacSink avec contrôle Pause
+
+**Distinction Radio vs Pistes finies:**
+
+| Mode | Comportement pendant Pause |
+|------|---------------------------|
+| **Radio (flux infini)** | Les chunks qui arrivent sont ignorés/perdus. On envoie du silence. La source continue à produire mais on n'en tient pas compte. |
+| **Pistes finies** | On bloque la consommation des chunks. Par backpressure, le pipeline en amont s'arrête (TimerBufferNode arrête d'envoyer). La lecture est truly arrêtée. |
+
+**Architecture actuelle analysée:**
+```
+AudioSegment → StreamingOggFlacSink → FLAC encoder → OGG wrapper → timed_broadcast → clients
+```
+
+**Implémentation suggérée:**
+
+1. **État de lecture distingué:**
+   - `PlaybackMode::Radio` - ignore les chunks entrants pendant pause
+   - `PlaybackMode::Track` - bloque la consommation (backpressure)
+
+2. **Dans SharedSinkContext:**
+   ```rust
+   pub enum PlaybackMode {
+       Radio,  // Flux infini - ignore chunks pendant pause
+       Track,  // Piste finie - block par backpressure
+   }
+   
+   pub playback_mode: PlaybackMode,
+   pub is_paused: Arc<AtomicBool>,
+   ```
+
+3. **Traitement différent selon le mode:**
+   - **Radio**: Si `is_paused`, envoyer silence (zéros) mais perdre les chunks entrants
+   - **Track**: Si `is_paused`, ne pas consommer les chunks → backpressure → arrêt du pipeline en amont
+
+4. **Transition automatique:**
+   - Détecter le type de contenu via les métadonnées du TrackBoundary
+   - **Enrichir TrackBoundary** avec un champ `stream_type`:
+     ```rust
+     pub enum StreamType {
+         Continuous,  // Radio/webcast - flux infini
+         Finite,       // Piste/album - flux avec fin définie
+     }
+     
+     pub stream_type: StreamType,
+     ```
+   - Si durée inconnue = Radio (Continuous), si durée connue = Track (Finite)

.kilo/plans/1775382570642-kind-falcon.md

@@ -0,0 +1,58 @@
+# Refonte de `pmowebrenderer` – Élimination des redondances
+
+## Objectif
+Réduire la duplication de code entre les fonctions de construction de services UPnP (`build_avtransport`, `build_renderingcontrol`, `build_connectionmanager`) et les macros d’ajout d’arguments (`add_arg_in!`, `add_arg_out!`).  
+Cela améliore la maintenabilité, la lisibilité et diminue le risque d’incohérences.
+
+## Étapes détaillées
+
+1. **Création d’une fonction générique `build_service`**
+   - Signature proposée:
+     ```rust
+     fn build_service(
+         name: &str,
+         variables: Vec<Arc<Variable>>,
+         actions: Vec<Action>,
+         handlers: Vec<Handler>,
+     ) -> Result<Service, FactoryError>
+     ```
+   - Implémentation unique de l’ajout de variables, d’actions et de handlers.
+   - Chaque fonction existante (`build_avtransport`, `build_renderingcontrol`, `build_connectionmanager`) appelle `build_service` avec les paramètres spécifiques.
+
+2. **Refactorisation des macros**
+   - Remplacer `macro_rules! add_arg_in!` et `add_arg_out!` par des fonctions如此一来 :
+     ```rust
+     fn add_arg_in(action: &mut Action, name: &str, var: Arc<Argument>) -> Result<(), FactoryError>
+     fn add_arg_out(action: &mut Action, name: &str, var: Arc<Argument>) -> Result<(), FactoryError>
+     ```
+   - Ces fonctions encapsulent la logique d’ajout d’arguments et centralisent la gestion d’erreur.
+
+3. **Mise à jour des implémentations**
+   - Modifier `build_avtransport`, `build_renderingcontrol`, `build_connectionmanager` pour déléguer à `build_service` et aux nouvelles fonctions d’argument.
+   - Vérifier que les imports restent cohérents (ajouter `use` nécessaires pour `Variable`, `Handler`, etc.).
+
+4. **Suppression des ancrés macros**
+   - Retirer les declarations `macro_rules! add_arg_in!` et `macro_rules! add_arg_out!` du fichier `renderer.rs`.
+   - Adapter le code appelant pour utiliser les fonctions concrètes.
+
+5. **Tests et CI**
+   - Ajouter des tests unitaires couvrant les nouvelles fonctions `build_service`, `add_arg_in`, `add_arg_out`.
+   - Configurer le pipeline CI pour exécuter `cargo test` et `cargo clippy` afin de détecter d’éventuelles regressions.
+
+6. **Documentation**
+   - Mettre à jour les commentaires pour refléter les nouvelles abstractions.
+   - Ajouter une section « Refactorisation » dans le `README` décrivant les changements.
+
+## Impact attendu
+- **Réduction** : ~12 lignes de code redondantes éliminées.
+- **Maintenabilité** : modification centralisée de la logique de construction de services.
+- **Robustesse** : baisse du risque d’incohérences et de bugs liés à la duplication.
+- **Lisibilité** : code plus explicite et plus proche du modèle de domaine.
+
+## Prochaines actions
+1. Implémenter les changements proposés dans les fichiers concernés.
+2. Exécuter la suite de tests pour valider la refonte.
+3. Commiter les modifications après revue.
+
+---  
+Plan finalisé.

.kilo/plans/1775386308232-quick-orchid.md

@@ -0,0 +1,108 @@
+# Plan: Suppression des duplications dans `@pmowebrenderer`
+
+## Objectif
+Éliminer les redondances de code identifiées lors de l'audit.
+
+---
+
+## Duplication 1: Helper functions dupliquées dans `renderer.rs`
+
+**Fichiers affectés**: `src/renderer.rs`
+
+**Problème**:
+- Lignes 17-54: `add_arg_in`, `add_arg_out`, `add_var`, `add_action` définies
+- Lignes 150-181: Dans `build_avtransport()`, réimplémentation locale avec closures `|svc, var| { ... }`
+- Répétition de 20+ appels `add_var(&mut svc, &VAR)?` et `add_action(&mut svc, Arc::new(action))?`
+
+**Solution**:
+1. Supprimer les closures locales redéclarées (lignes 150-181)
+2. Utiliser directement les fonctions helpers du haut du fichier
+3. Créer une macro ou fonction utilitaire pour les appels répétés:
+   ```rust
+   macro_rules! add_vars {
+       ($svc:expr, $($var:expr),*) => { $({ add_var($svc, &$var)?; })* };
+   }
+   ```
+
+---
+
+## Duplication 2: Pattern handlers boilerplate dans `handlers.rs`
+
+**Fichiers affectés**: `src/handlers.rs`
+
+**Problème**:
+- `play_handler`, `stop_handler`, `pause_handler` (lignes 23-71): structure identique
+- `next_handler`, `previous_handler` (lignes 74-95): clones
+- Handlers GET (lignes 166-317): pattern `state.clone()` + `Box::pin(async move { ... set!() ... })` dupliqué
+
+**Solution**:
+1. Créer un helper générique:
+   ```rust
+   fn make_state_handler<F>(state: SharedState, f: F) -> ActionHandler
+   where F: FnOnce(&mut ActionData, &RendererState) -> Result<ActionData, ActionError> + Send + 'static
+   ```
+2. Factoriser les closures `let state = state.clone()` dans chaque handler
+
+---
+
+## Duplication 3: Extraction metadata dupliquée
+
+**Fichiers affectés**: `src/handlers.rs`
+
+**Problème**:
+- Lignes 118-123: `set_uri_handler` extraction metadata
+- Lignes 146-151: `set_next_uri_handler` extraction metadata (identique)
+
+**Solution**:
+1. Extraire en fonction utilitaire:
+   ```rust
+   fn extract_metadata(data: &ActionData, key: &str) -> String { ... }
+   ```
+
+---
+
+## Duplication 4: Méthodes pipeline dans `registry.rs`
+
+**Fichiers affectés**: `src/registry.rs`
+
+**Problème**:
+- `send_pipeline_command` (lignes 272-279) appelle `get_pipeline` (lignes 281-283)
+- `load_uri` (lignes 286-290), `send_play_command` (lignes 293-296), `send_pause_command` (lignes 299-301) sont des wrappers quasi-identiques
+
+**Solution**:
+Consolider en méthodes génériques:
+```rust
+pub async fn send_command(&self, instance_id: &str, cmd: PipelineControl) {
+    if let Some(pipeline) = self.get_pipeline(instance_id) {
+        pipeline.send(cmd).await;
+    }
+}
+```
+
+---
+
+## Duplication 5: Feature flags avec code dupliqué
+
+**Fichiers affectés**: `src/registry.rs`
+
+**Problème**:
+- Lignes 51-68 et 334-395: double impl de `create_instance` selon feature
+
+**Solution**:
+- Extraire la logique commune dans une fonction privée
+- Utiliser `#[cfg]` seulement pour les différences (appel à pmoserver)
+
+---
+
+## Ordre de traitement suggéré
+
+1. **Phase 1**: Helpers dans `renderer.rs` (les plus simples)
+2. **Phase 2**: Handlers dans `handlers.rs` (plus complexe, nécessite macro)
+3. **Phase 3**: Méthodes pipeline dans `registry.rs`
+4. **Phase 4**: Feature flags
+
+## Vérification
+Après chaque phase, exécuter:
+```bash
+cargo check --package pmowebrenderer
+```

.kilo/plans/1775631632458-happy-cactus.md

@@ -0,0 +1,225 @@
+# Audit PMO Control - Optimisation Playlist OpenHome
+
+## Résumé Exécutif
+
+L'utilisateur rapporte des lenteurs significatives lors de la manipulation de playlists de ~1000 titres avec les renderers OpenHome. Les renderers Chromecast et UPnP (avec queue interne) ne sont pas affectés.
+
+## État des Optimisations Deja Implémentées
+
+Le precedent plan dans `Blackboard/Todo/enorme_playlist.md` a deja été partiellement implémenté:
+
+| optimisation | Statut | Emplacement |
+|-------------|-------|------------|
+| MAX_BATCH = 256 pour ReadList | ✅ FAIT | `openhome.rs:1015` |
+| Élimination double queue_snapshot() | ✅ FAIT | `replace_queue_with_pivot()` et `replace_queue_standard_lcs()` |
+| LCS préfixe/suffixe (lcs_flags_optimized) | ✅ FAIT | `openhome.rs:869` |
+| Polling adaptatif (is_active) | ✅ FAIT | `musicrenderer.rs:325-374` |
+| Consolidation invalidation caches | ✅ FAIT | `openhome.rs:222-235` |
+
+## Contraintes Protocolaires Découvertes
+
+L'action `Insert` **ne supporte PAS l'insertion par lot** - chaque appel prend un seul Uri/Metadata.
+
+## Nouvelles Optimisations (Contre-propositions Utilisateur)
+
+### OPT-1: Fast Path pour 99% des cas de sync_queue
+
+**Observation**: 99% des changements de playlist sont:
+- Insertion de nouvelles tracks en **fin de queue**
+- Délétion de tracks en **début de queue**
+- Rarement des changements nécessitant un vrai alignement LCS
+
+**Solution**: Ajouter une détection de pattern avant d'appeler LCS:
+
+```rust
+fn smart_sync(&mut self, items: Vec<PlaybackItem>) -> Result<(), ControlPointError> {
+    let current_ids = self.track_ids()?;
+    
+    // Cas 1: Append only (insertion en fin)
+    if items.starts_with(&current_ids) {
+        // Fast path: juste ajouter les nouveaux items
+        return self.append_only(items.skip(current_ids.len()));
+    }
+    
+    // Cas 2: Delete from beginning
+    if current_ids.starts_with(&items) {
+        // Fast path: supprimer de la fin
+        return self.delete_from_beginning(current_ids.len() - items.len());
+    }
+    
+    // Cas 3: Full LCS only for complex reorderings
+    return self.replace_queue_standard_lcs(items);
+}
+```
+
+**Impact**: 99% des sync_queue passent de O(N²) à O(N)
+
+---
+
+### OPT-2: Queue FIFO pour Opérations OpenHome (Thread Background)
+
+**Concept**: Une file d'attente FIFO des opérations SOAP exécutée dans un thread dédié.
+
+```rust
+pub struct OpenHomeOpQueue {
+    queue: Arc<Mutex<Vec<OpenHomeOp>>>,
+    worker_handle: Option<JoinHandle<()>>,
+}
+
+pub enum OpenHomeOp {
+    Insert { uri: String, metadata: String, after_id: u32 },
+    Delete { track_id: u32 },
+    DeleteAll,
+    SeekId { id: u32 },
+    Play,
+    Pause,
+    Stop,
+    SetVolume { volume: u16 },
+    // Meta operations
+    UpdateMetadata { track_id: u32, metadata: String },
+}
+
+impl OpenHomeOpQueue {
+    /// Push operation to the FIFO queue
+    pub fn push(&self, op: OpenHomeOp) {
+        self.queue.lock().unwrap().push(op);
+    }
+    
+    /// Push with priority (volume, play, stop - need fast response)
+    pub fn push_first(&self, op: OpenHomeOp) {
+        self.queue.lock().unwrap().push_front(op);
+    }
+    
+    /// Clear all pending operations (client can flush)
+    pub fn clear(&self) {
+        self.queue.lock().unwrap().clear();
+    }
+    
+    /// Worker thread consumes operations
+    fn worker_loop(&self) {
+        loop {
+            let op = self.queue.lock().unwrap().pop_front();
+            match op {
+                Some(op) => self.execute(op),
+                None => thread::sleep(Duration::from_millis(10)),
+            }
+        }
+    }
+}
+```
+
+**Benefits**:
+- UI non-bloquante (les operations sont lancées et exec en background)
+- Batching naturel (plusieurs operations sont executes en sequence)
+- Priorité via `push_first()` pour play/stop/volume
+- `clear()` permet d'annuler les operations en attente (ex: playlist changée)
+
+**Implémentation suggérée**:
+1. Créer `src/queue/openhome_op_queue.rs` avec la structure
+2. Intégrer dans `OpenHomeQueue` ou `OpenHomeRenderer`
+3. Thread de worker lancé au démarrage du control point
+
+---
+
+### OPT-3: Métadonnées en Tâche de Fond
+
+**Observation**: L'appli utilise-t-elle vraiment les métadonnées de la queue OpenHome, ou un cache local?
+
+Si le control-point maintient son propre cache (plus probable):
+- Les mises à jour de métadonnées peuvent être traitées en background
+- Pas besoin de sync immédiate des métadonnées
+
+**Solution**: Queue séparée pour les operations de métadonnées:
+
+```rust
+// Haute priorité (opérations critiques)
+let high_priority_queue: OpenHomeOpQueue;
+
+// Basse priorité (métadonnées)
+let metadata_queue: OpenHomeOpQueue;
+```
+
+**Implémentation**:
+1. Séparer les operations critiques (play/stop/seek/volume) de metadata
+2. Metadata update traités en background avec délais
+3. Le cache local du control-point est mis à jour indépendamment
+
+---
+
+### OPT-4: Connection Pooling HTTP
+
+Chaque appel SOAP crée une nouvelle connexion. Avec 1000 insertions:
+- Overhead TCP: ~10-50ms par appel
+- Total: 10-50 secondes overhead réseau
+
+**Solution**: Agent HTTP static avec connection reuse:
+
+```rust
+// soap_client.rs
+static HTTP_AGENT: Lazy<ureq::Agent> = Lazy::new(|| {
+    Agent::config_builder()
+        .timeout_global(Some(Duration::from_secs(30)))
+        .build()
+});
+```
+
+---
+
+## Plan d'Implémentation Proposé
+
+### Phase 1: Fast Path LCS (Priorité Haute)
+
+1. Ajouter `detect_sync_pattern()` dans `openhome.rs`
+2. Implémenter `append_only()` et `delete_from_beginning()`
+3. Tester avec playlists réelles
+
+### Phase 2: Queue FIFO Opérations (Priorité Haute)
+
+1. Créer `src/queue/openhome_op_queue.rs`
+2. Implémenter `push()`, `push_first()`, `clear()`
+3. Thread worker avec loop de consommation
+4. Intégrer dans `OpenHomeRenderer`
+
+### Phase 3: Séparation Métadonnées (Priorité Moyenne)
+
+1. Créer queue séparée pour metadata
+2. Implémenter batch processing
+
+### Phase 4: Connection Pooling (Priorité Basse)
+
+1. Modifier `soap_client.rs` pour agent static
+
+---
+
+## Questions pour Clarification
+
+1. **Cache Métadonnées**: Le control-point utilise-t-il vraiment les métadonnées de la queue OpenHome, ou maintient-il son propre cache qui est alimenté indépendamment?
+
+2. **Priorité des Opérations**: Pour `push_first()`, quelles opérations nécessitent une réponse rapide?
+   - Volume (immédiat)
+   - Play/Pause/Stop (immédiat)
+   - Seek (rapide)
+   - Insert (peut être différé)
+
+3. **Comportement en cas de conflit**: Si le client fait `clear()` et que le worker est en train d'exécuter une opération:
+   - Annuler l'opération en cours? ( risky - peut laisser le renderer dans un état inconsistent)
+   - Laisser finir l'opération en cours? (plus sur)
+
+---
+
+## Tests Recommandés
+
+```bash
+# Compiler
+cargo build -p pmocontrol
+
+# Benchmark LCS fast paths
+# - Cas: append 100 tracks to 900 = O(N)
+# - Cas: delete 100 from 900 = O(N)  
+# - Cas: reorder = O(N²) avec LCS
+```
+
+---
+
+*Plan mis à jour avec contre-propositions utilisateur*
+*Date: 2026-04-08*

Blackboard/Architecture/music_source.md

@@ -0,0 +1,921 @@
+# Guide d'implémentation d'une nouvelle MusicSource
+
+Ce document décrit comment implémenter une nouvelle source musicale dans l'écosystème PMOMusic en suivant le trait `MusicSource` défini dans le crate `pmosource`.
+
+## Table des matières
+
+1. [Vue d'ensemble](#vue-densemble)
+2. [Structure d'une MusicSource](#structure-dune-musicsource)
+3. [Implémentation du trait MusicSource](#implémentation-du-trait-musicsource)
+4. [Patterns d'implémentation](#patterns-dimplémentation)
+5. [Intégration avec l'écosystème PMOMusic](#intégration-avec-lécosystème-pmomusic)
+6. [Checklist de mise en œuvre](#checklist-de-mise-en-œuvre)
+7. [Exemples de référence](#exemples-de-référence)
+
+## Vue d'ensemble
+
+Une `MusicSource` est une abstraction qui représente une source de contenu musical dans PMOMusic. Elle peut être :
+
+- **Dynamique (FIFO)** : Radio Paradise, streaming radio, playlists live
+- **Statique** : Albums Qobuz, bibliothèque locale, playlists fixes
+
+Le trait `MusicSource` définit une interface unifiée pour :
+- La navigation UPnP ContentDirectory (browse)
+- La résolution d'URI audio (avec cache)
+- La gestion de playlists FIFO (pour les sources dynamiques)
+- Le suivi des changements (update_id, last_change)
+
+## Structure d'une MusicSource
+
+### Organisation du code
+
+```
+pmo<votre-source>/
+├── src/
+│   ├── lib.rs              # Exports publics
+│   ├── source.rs           # Implémentation MusicSource
+│   ├── client.rs           # Client API (optionnel)
+│   ├── models.rs           # Structures de données
+│   ├── config.rs           # Configuration
+│   └── didl.rs             # Conversion DIDL-Lite (optionnel)
+├── assets/
+│   └── default.webp        # Logo 300x300px
+├── Cargo.toml
+└── README.md
+```
+
+### Dépendances principales
+
+```toml
+[dependencies]
+pmosource = { path = "../pmosource" }
+pmodidl = { path = "../pmodidl" }
+pmoplaylist = { path = "../pmoplaylist", optional = true }  # Si FIFO
+pmoaudiocache = { path = "../pmoaudiocache", optional = true }  # Si cache
+pmocovers = { path = "../pmocovers", optional = true }  # Si cache
+
+async-trait = "0.1"
+tokio = { version = "1", features = ["sync"] }
+serde = { version = "1", features = ["derive"] }
+
+[features]
+default = ["cache"]
+cache = ["pmoaudiocache", "pmocovers"]
+playlist = ["pmoplaylist"]
+```
+
+## Implémentation du trait MusicSource
+
+### 1. Informations de base
+
+Chaque source doit fournir :
+
+```rust
+use pmosource::{async_trait, MusicSource};
+
+#[derive(Clone, Debug)]
+pub struct MyMusicSource {
+    // Champs internes
+}
+
+#[async_trait]
+impl MusicSource for MyMusicSource {
+    fn name(&self) -> &str {
+        "Ma Source Musicale"  // Nom affiché dans l'UI
+    }
+
+    fn id(&self) -> &str {
+        "my-music-source"  // ID unique (format: lowercase-kebab-case)
+    }
+
+    fn default_image(&self) -> &[u8] {
+        // Logo WebP 300x300px inclus dans le binaire
+        include_bytes!("../assets/default.webp")
+    }
+
+    fn default_image_mime_type(&self) -> &str {
+        "image/webp"  // Toujours WebP
+    }
+}
+```
+
+**Règles :**
+- `id()` doit être unique parmi toutes les sources
+- `id()` doit être en lowercase-kebab-case
+- `default_image()` doit être un WebP 300x300px
+
+### 2. Navigation ContentDirectory
+
+#### 2.1 Container racine
+
+```rust
+async fn root_container(&self) -> Result<Container> {
+    Ok(Container {
+        id: self.id().to_string(),  // "my-music-source"
+        parent_id: "0".to_string(),  // Toujours "0" pour la racine
+        restricted: Some("1".to_string()),
+        child_count: None,  // Optionnel
+        searchable: Some("1".to_string()),
+        title: self.name().to_string(),
+        class: "object.container".to_string(),
+        artist: None,
+        album_art: None,
+        containers: vec![],
+        items: vec![],
+    })
+}
+```
+
+#### 2.2 Browse
+
+La méthode `browse()` est le cœur de la navigation :
+
+```rust
+async fn browse(&self, object_id: &str) -> Result<BrowseResult> {
+    match self.parse_object_id(object_id) {
+        ObjectIdType::Root => {
+            // Retourner les sous-containers principaux
+            let containers = vec![
+                self.build_albums_container(),
+                self.build_playlists_container(),
+                self.build_favorites_container(),
+            ];
+            Ok(BrowseResult::Containers(containers))
+        }
+
+        ObjectIdType::Album { album_id } => {
+            // Retourner le container + ses tracks
+            let album_container = self.build_album_container(&album_id);
+            let tracks = self.get_album_tracks(&album_id).await?;
+            Ok(BrowseResult::Mixed {
+                containers: vec![album_container],
+                items: tracks,
+            })
+        }
+
+        ObjectIdType::Track { track_id } => {
+            // Retourner les détails d'un track
+            let track = self.get_track_item(&track_id).await?;
+            Ok(BrowseResult::Items(vec![track]))
+        }
+
+        _ => Err(MusicSourceError::ObjectNotFound(
+            format!("Unknown object: {}", object_id)
+        ))
+    }
+}
+```
+
+**Schema d'Object ID recommandé :**
+
+```
+<source-id>                              # Racine
+<source-id>:albums                       # Container albums
+<source-id>:album:<album_id>             # Album spécifique
+<source-id>:track:<track_id>             # Track spécifique
+<source-id>:playlist:<playlist_id>       # Playlist spécifique
+```
+
+**Types de BrowseResult :**
+- `Containers(Vec<Container>)` : Liste de containers (navigation)
+- `Items(Vec<Item>)` : Liste de tracks (lecture)
+- `Mixed { containers, items }` : Les deux (album avec tracks)
+
+#### 2.3 Résolution d'URI
+
+```rust
+async fn resolve_uri(&self, object_id: &str) -> Result<String> {
+    // Étape 1 : Vérifier le cache audio
+    if let Some(cached_pk) = self.get_cached_audio_pk(object_id).await {
+        return Ok(format!("{}/audio/flac/{}", self.base_url, cached_pk));
+    }
+
+    // Étape 2 : Retourner l'URI originale
+    match self.parse_object_id(object_id) {
+        ObjectIdType::Track { track_id } => {
+            let stream_url = self.get_stream_url(&track_id).await?;
+            Ok(stream_url)
+        }
+        _ => Err(MusicSourceError::UriResolutionError(
+            format!("Cannot resolve URI for: {}", object_id)
+        ))
+    }
+}
+```
+
+**Ordre de résolution :**
+1. Cache audio local (si disponible)
+2. URI originale (API streaming, fichier local, etc.)
+
+### 3. Support FIFO (sources dynamiques)
+
+Si votre source est dynamique (radio, streaming live) :
+
+```rust
+use pmoplaylist::PlaylistManager;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[derive(Clone)]
+pub struct RadioSource {
+    playlist_id: String,
+    update_counter: Arc<RwLock<u32>>,
+    last_change: Arc<RwLock<SystemTime>>,
+}
+
+#[async_trait]
+impl MusicSource for RadioSource {
+    fn supports_fifo(&self) -> bool {
+        true  // Cette source utilise une FIFO
+    }
+
+    async fn append_track(&self, track: Item) -> Result<()> {
+        // Récupérer le gestionnaire de playlist
+        let manager = PlaylistManager();
+        let writer = manager
+            .get_persistent_write_handle(self.playlist_id.clone())
+            .await
+            .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?;
+
+        // Extraire le PK depuis l'URI du track
+        let pk = self.extract_pk_from_item(&track)?;
+
+        // Ajouter à la playlist
+        writer
+            .push_lazy(pk)
+            .await
+            .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?;
+
+        // Incrémenter update_id
+        self.bump_update_counter().await;
+
+        Ok(())
+    }
+
+    async fn remove_oldest(&self) -> Result<Option<Item>> {
+        let manager = PlaylistManager();
+        let reader = manager
+            .get_read_handle(&self.playlist_id)
+            .await
+            .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?;
+
+        // Récupérer le plus ancien
+        let items = reader.to_items(1).await
+            .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?;
+
+        if let Some(item) = items.first() {
+            // Adapter l'item au schéma de la source
+            let adapted = self.adapt_item_to_schema(item.clone());
+            self.bump_update_counter().await;
+            Ok(Some(adapted))
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn update_id(&self) -> u32 {
+        *self.update_counter.read().await
+    }
+
+    async fn last_change(&self) -> Option<SystemTime> {
+        Some(*self.last_change.read().await)
+    }
+
+    async fn get_items(&self, offset: usize, count: usize) -> Result<Vec<Item>> {
+        let manager = PlaylistManager();
+        let reader = manager
+            .get_read_handle(&self.playlist_id)
+            .await
+            .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?;
+
+        // Récupérer les items
+        let items = reader
+            .to_items(count)
+            .await
+            .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?;
+
+        // Adapter au schéma de la source
+        let adapted = items.into_iter()
+            .map(|item| self.adapt_item_to_schema(item))
+            .collect();
+
+        Ok(adapted)
+    }
+}
+
+impl RadioSource {
+    async fn bump_update_counter(&self) {
+        let mut counter = self.update_counter.write().await;
+        *counter = counter.wrapping_add(1).max(1);
+        let mut last = self.last_change.write().await;
+        *last = SystemTime::now();
+    }
+}
+```
+
+**Points clés :**
+- Utiliser `pmoplaylist::PlaylistManager` singleton
+- Incrémenter `update_id` à chaque modification
+- Mettre à jour `last_change` à chaque modification
+- Adapter les IDs des items au schéma de la source
+
+### 4. Support statique (albums, bibliothèques)
+
+Si votre source est statique (catalogue, albums) :
+
+```rust
+#[async_trait]
+impl MusicSource for CatalogSource {
+    fn supports_fifo(&self) -> bool {
+        false  // Pas de FIFO
+    }
+
+    async fn append_track(&self, _track: Item) -> Result<()> {
+        Err(MusicSourceError::NotSupported(
+            "This source is read-only".to_string()
+        ))
+    }
+
+    async fn remove_oldest(&self) -> Result<Option<Item>> {
+        Ok(None)  // Pas de suppression
+    }
+
+    async fn update_id(&self) -> u32 {
+        0  // Jamais de changement
+    }
+
+    async fn last_change(&self) -> Option<SystemTime> {
+        None  // Pas de suivi des changements
+    }
+
+    async fn get_items(&self, offset: usize, count: usize) -> Result<Vec<Item>> {
+        // Retourner une liste paginée depuis le catalogue
+        self.get_catalog_items(offset, count).await
+    }
+}
+```
+
+## Patterns d'implémentation
+
+### Pattern 1 : Source dynamique avec FIFO (Radio Paradise)
+
+**Caractéristiques :**
+- Flux continu de tracks
+- Capacité limitée (50-100 tracks)
+- Suppression automatique des plus anciens
+- `supports_fifo() = true`
+
+**Structure :**
+
+```rust
+#[derive(Clone)]
+pub struct RadioParadiseSource {
+    base_url: String,
+    update_counter: Arc<RwLock<u32>>,
+    last_change: Arc<RwLock<SystemTime>>,
+    callback_tokens: Arc<std::sync::Mutex<Vec<u64>>>,
+    container_notifier: Option<Arc<dyn Fn(&[String]) + Send + Sync>>,
+}
+
+impl RadioParadiseSource {
+    // Enregistrer des callbacks sur les playlists pour notifier les changements
+    pub fn attach_playlist_callbacks(self: &Arc<Self>) {
+        let playlist_ids = vec![
+            self.live_playlist_id(),
+            self.history_playlist_id(),
+        ];
+
+        let manager = PlaylistManager();
+        let mut tokens = self.callback_tokens.lock().unwrap();
+
+        for pid in playlist_ids {
+            let weak = Arc::downgrade(self);
+            let pid_clone = pid.clone();
+            let token = manager.register_callback(move |event| {
+                if event.playlist_id == pid_clone {
+                    if let Some(strong) = weak.upgrade() {
+                        tokio::spawn(async move {
+                            strong.bump_update_counter().await;
+                            // Notifier ContentDirectory
+                            if let Some(notifier) = strong.container_notifier.as_ref() {
+                                notifier(&[format!("radio-paradise:history")]);
+                            }
+                        });
+                    }
+                }
+            });
+            tokens.push(token);
+        }
+    }
+}
+```
+
+**Points clés :**
+- Callbacks sur `pmoplaylist` pour détecter les changements
+- Notification du ContentDirectory via un notifier injecté
+- `update_counter` partagé via `Arc<RwLock<u32>>`
+
+### Pattern 2 : Source catalogue avec playlists lazy (Qobuz)
+
+**Caractéristiques :**
+- Catalogue vaste (millions de tracks)
+- Playlists créées à la demande
+- Cache lazy (cover eager, audio lazy)
+- `supports_fifo() = false`
+
+**Structure :**
+
+```rust
+#[derive(Clone)]
+pub struct QobuzSource {
+    inner: Arc<QobuzSourceInner>,
+}
+
+struct QobuzSourceInner {
+    client: Arc<QobuzClient>,
+    cache_manager: SourceCacheManager,
+    base_url: String,
+    update_counter: tokio::sync::RwLock<u32>,
+    last_change: tokio::sync::RwLock<SystemTime>,
+}
+
+impl QobuzSource {
+    // Ajouter un track avec cache lazy
+    pub async fn add_track_lazy(&self, track: &Track) -> Result<(String, String)> {
+        let track_id = format!("qobuz://track/{}", track.id);
+        let lazy_pk = format!("QOBUZ:{}", track.id);
+
+        // 1. Cache cover EAGERLY (petit, UI en a besoin)
+        let cached_cover_pk = if let Some(ref image_url) = track.album.as_ref()
+            .and_then(|a| a.image.as_ref()) {
+            self.inner.cache_manager.cache_cover(image_url).await.ok()
+        } else {
+            None
+        };
+
+        // 2. Préparer metadata
+        let metadata = AudioMetadata {
+            title: Some(track.title.clone()),
+            artist: track.performer.as_ref().map(|p| p.name.clone()),
+            album: track.album.as_ref().map(|a| a.title.clone()),
+            duration_secs: Some(track.duration as u64),
+            // ... autres champs
+        };
+
+        // 3. Cache audio LAZILY (grand, téléchargé à la demande)
+        let cached_audio_pk = self
+            .inner
+            .cache_manager
+            .cache_audio_lazy_with_provider(
+                &lazy_pk,
+                Some(metadata.clone()),
+                cached_cover_pk.clone(),
+            )
+            .await?;
+
+        // 4. Stocker metadata
+        self.inner.cache_manager.update_metadata(
+            track_id.clone(),
+            pmosource::TrackMetadata {
+                original_uri: stream_url,
+                cached_audio_pk: Some(cached_audio_pk.clone()),
+                cached_cover_pk,
+            },
+        ).await;
+
+        Ok((track_id, cached_audio_pk))
+    }
+
+    // Créer une playlist d'album avec TTL
+    async fn get_or_create_album_playlist_items(
+        &self,
+        album_id: &str,
+        limit: usize,
+    ) -> Result<Vec<Item>> {
+        const ALBUM_PLAYLIST_TTL: Duration = Duration::from_secs(7 * 24 * 3600);
+
+        let playlist_id = format!("qobuz-album-{}", album_id);
+        let playlist_manager = PlaylistManager();
+
+        // Vérifier validité (existe ET non expirée ET non vide)
+        let is_valid = self.is_album_playlist_valid(&playlist_id).await?;
+
+        if is_valid {
+            // Récupérer depuis playlist existante
+            let reader = playlist_manager.get_read_handle(&playlist_id).await?;
+            let items = reader.to_items(limit).await?;
+            return self.adapt_playlist_items_to_qobuz(items, album_id).await;
+        }
+
+        // Créer nouvelle playlist
+        let writer = playlist_manager
+            .create_persistent_playlist_with_role(
+                playlist_id.clone(),
+                pmoplaylist::PlaylistRole::Album,
+            )
+            .await?;
+
+        // Ajouter tracks avec cache lazy
+        self.add_album_to_playlist(&playlist_id, album_id).await?;
+
+        // Récupérer items
+        let reader = playlist_manager.get_read_handle(&playlist_id).await?;
+        let items = reader.to_items(limit).await?;
+        self.adapt_playlist_items_to_qobuz(items, album_id).await
+    }
+}
+```
+
+**Points clés :**
+- Cache lazy pour l'audio (téléchargé à la demande)
+- Cache eager pour les covers (petit, UI en a besoin)
+- Playlists avec TTL (7 jours)
+- `LazyProvider` pour télécharger l'audio lors de la lecture
+
+### Pattern 3 : Adaptation des IDs entre playlist et source
+
+Lorsqu'une source utilise `pmoplaylist`, les items retournés ont des IDs génériques. Il faut les adapter au schéma de la source :
+
+```rust
+async fn adapt_playlist_items_to_source(
+    &self,
+    items: Vec<Item>,
+    parent_id: &str,
+) -> Result<Vec<Item>> {
+    let mut adapted = Vec::with_capacity(items.len());
+
+    for mut item in items {
+        // Extraire cache_pk depuis l'URL du resource
+        let cache_pk = if let Some(resource) = item.resources.first() {
+            resource
+                .url
+                .strip_prefix("/audio/flac/")
+                .map(|s| s.to_string())
+        } else {
+            None
+        };
+
+        if let Some(pk) = cache_pk {
+            // Récupérer source_track_id depuis metadata
+            if let Ok(Some(track_id_value)) = self
+                .cache_manager
+                .get_audio_metadata(&pk, "source_track_id")
+            {
+                if let Some(track_id) = track_id_value.as_str() {
+                    item.id = format!("my-source:track:{}", track_id);
+                }
+            }
+
+            // Convertir URL relative en absolue
+            if let Some(resource) = item.resources.first_mut() {
+                if resource.url.starts_with('/') {
+                    resource.url = format!("{}{}", self.base_url, resource.url);
+                }
+            }
+        }
+
+        item.parent_id = parent_id.to_string();
+
+        // Normaliser album art
+        if let Some(art) = item.album_art.as_mut() {
+            if art.starts_with('/') {
+                *art = format!("{}{}", self.base_url, art);
+            }
+        } else {
+            item.album_art = Some(self.default_cover_url());
+        }
+
+        // Ajouter genre par défaut si absent (requis par certains clients)
+        if item.genre.is_none() {
+            item.genre = Some("Music".to_string());
+        }
+
+        adapted.push(item);
+    }
+
+    Ok(adapted)
+}
+```
+
+**Points clés :**
+- Stocker `source_track_id` dans les metadata du cache audio
+- Reconstituer l'ID correct lors de la récupération depuis playlist
+- Normaliser URLs (relatives → absolues)
+- Ajouter champs requis par certains clients UPnP
+
+## Intégration avec l'écosystème PMOMusic
+
+### Avec pmoplaylist
+
+Pour les sources dynamiques et les catalogues :
+
+```rust
+use pmoplaylist::{PlaylistManager, PlaylistRole};
+
+// Créer une playlist persistante
+let manager = PlaylistManager();
+let writer = manager
+    .create_persistent_playlist_with_role(
+        "my-source-album-123".to_string(),
+        PlaylistRole::Album,
+    )
+    .await?;
+
+// Configurer metadata
+writer.set_title("Album Title".to_string()).await?;
+writer.set_artist(Some("Artist Name".to_string())).await?;
+writer.set_cover_pk(Some("cover-pk".to_string())).await?;
+
+// Ajouter tracks avec cache lazy
+writer.push_lazy_batch(vec!["pk1", "pk2", "pk3"]).await?;
+
+// Activer mode lazy (lookahead 2 tracks)
+manager.enable_lazy_mode("my-source-album-123", 2);
+```
+
+### Avec pmoaudiocache et pmocovers (via SourceCacheManager)
+
+```rust
+use pmosource::SourceCacheManager;
+
+// Créer le manager centralisé
+let cache_manager = SourceCacheManager::from_registry("my-source".to_string())?;
+
+// Enregistrer un LazyProvider
+cache_manager.register_lazy_provider(Arc::new(MyLazyProvider::new(client)));
+
+// Cache eager (cover)
+let cover_pk = cache_manager.cache_cover("https://example.com/cover.jpg").await?;
+
+// Cache lazy (audio)
+let audio_pk = cache_manager
+    .cache_audio_lazy_with_provider(
+        "MY-SOURCE:123",  // Lazy PK
+        Some(metadata),
+        Some(cover_pk),
+    )
+    .await?;
+
+// Récupérer metadata
+let value = cache_manager.get_audio_metadata(&audio_pk, "key").await?;
+```
+
+**LazyProvider personnalisé :**
+
+```rust
+use pmoaudiocache::{LazyProvider, LazyProviderError};
+
+pub struct MyLazyProvider {
+    client: Arc<MyClient>,
+}
+
+#[async_trait]
+impl LazyProvider for MyLazyProvider {
+    async fn fetch_audio(&self, lazy_pk: &str) -> Result<Vec<u8>, LazyProviderError> {
+        // Extraire l'ID depuis le lazy_pk
+        let id = lazy_pk
+            .strip_prefix("MY-SOURCE:")
+            .ok_or_else(|| LazyProviderError::InvalidKey)?;
+
+        // Récupérer l'URL de streaming
+        let stream_url = self.client.get_stream_url(id).await
+            .map_err(|e| LazyProviderError::FetchFailed(e.to_string()))?;
+
+        // Télécharger l'audio
+        let response = reqwest::get(&stream_url).await
+            .map_err(|e| LazyProviderError::FetchFailed(e.to_string()))?;
+
+        let bytes = response.bytes().await
+            .map_err(|e| LazyProviderError::FetchFailed(e.to_string()))?;
+
+        Ok(bytes.to_vec())
+    }
+}
+```
+
+### Avec pmodidl
+
+Conversion de vos structures en DIDL-Lite :
+
+```rust
+use pmodidl::{Container, Item, Resource};
+
+// Container
+pub trait ToDIDLContainer {
+    fn to_didl_container(&self, parent_id: &str) -> Result<Container>;
+}
+
+impl ToDIDLContainer for MyAlbum {
+    fn to_didl_container(&self, parent_id: &str) -> Result<Container> {
+        Ok(Container {
+            id: format!("my-source:album:{}", self.id),
+            parent_id: parent_id.to_string(),
+            restricted: Some("1".to_string()),
+            child_count: self.tracks_count.map(|c| c.to_string()),
+            searchable: Some("1".to_string()),
+            title: self.title.clone(),
+            class: "object.container.album.musicAlbum".to_string(),
+            artist: Some(self.artist.name.clone()),
+            album_art: self.cover_url.clone(),
+            containers: vec![],
+            items: vec![],
+        })
+    }
+}
+
+// Item
+pub trait ToDIDLItem {
+    fn to_didl_item(&self, parent_id: &str) -> Result<Item>;
+}
+
+impl ToDIDLItem for MyTrack {
+    fn to_didl_item(&self, parent_id: &str) -> Result<Item> {
+        Ok(Item {
+            id: format!("my-source:track:{}", self.id),
+            parent_id: parent_id.to_string(),
+            restricted: Some("1".to_string()),
+            title: self.title.clone(),
+            creator: self.artist.as_ref().map(|a| a.name.clone()),
+            class: "object.item.audioItem.musicTrack".to_string(),
+            artist: self.artist.as_ref().map(|a| a.name.clone()),
+            album: self.album.as_ref().map(|a| a.title.clone()),
+            genre: Some("Music".to_string()),
+            album_art: self.cover_url.clone(),
+            album_art_pk: self.cover_pk.clone(),
+            date: self.release_date.clone(),
+            original_track_number: Some(self.track_number),
+            resources: vec![Resource {
+                protocol_info: "http-get:*:audio/flac:*".to_string(),
+                bits_per_sample: self.bit_depth.map(|b| b.to_string()),
+                sample_frequency: self.sample_rate.map(|s| s.to_string()),
+                nr_audio_channels: Some("2".to_string()),
+                duration: self.duration_as_upnp_format(),
+                url: format!("/audio/flac/{}", self.cache_pk),
+            }],
+            descriptions: vec![],
+        })
+    }
+}
+```
+
+## Checklist de mise en œuvre
+
+### Phase 1 : Structure de base
+
+- [ ] Créer le crate `pmo<votre-source>`
+- [ ] Ajouter les dépendances dans `Cargo.toml`
+- [ ] Créer le logo WebP 300x300px dans `assets/`
+- [ ] Définir la structure principale
+- [ ] Implémenter `name()`, `id()`, `default_image()`
+
+### Phase 2 : Navigation ContentDirectory
+
+- [ ] Définir le schéma d'Object ID
+- [ ] Implémenter `root_container()`
+- [ ] Implémenter `browse()` pour la racine
+- [ ] Implémenter `browse()` pour les sous-containers
+- [ ] Implémenter `browse()` pour les items
+- [ ] Tester la navigation avec un client UPnP
+
+### Phase 3 : Résolution d'URI
+
+- [ ] Implémenter `resolve_uri()` avec fallback
+- [ ] Intégrer avec `SourceCacheManager`
+- [ ] Implémenter `LazyProvider` si cache lazy
+- [ ] Tester la lecture audio
+
+### Phase 4 : Support FIFO (si dynamique)
+
+- [ ] Décider de la stratégie FIFO
+- [ ] Implémenter `supports_fifo() = true`
+- [ ] Implémenter `append_track()`
+- [ ] Implémenter `remove_oldest()`
+- [ ] Implémenter `update_id()` et `last_change()`
+- [ ] Enregistrer callbacks sur playlists
+- [ ] Tester ajout/suppression de tracks
+
+### Phase 5 : Support statique (si catalogue)
+
+- [ ] Implémenter `supports_fifo() = false`
+- [ ] Implémenter `get_items()` avec pagination
+- [ ] Implémenter `search()` si applicable
+- [ ] Tester browsing du catalogue
+
+### Phase 6 : Intégration avancée
+
+- [ ] Implémenter `get_item()` pour metadata
+- [ ] Implémenter `capabilities()`
+- [ ] Implémenter `get_available_formats()`
+- [ ] Ajouter gestion d'erreurs robuste
+- [ ] Documenter le code
+
+### Phase 7 : Tests et validation
+
+- [ ] Écrire tests unitaires
+- [ ] Écrire tests d'intégration
+- [ ] Tester avec différents clients UPnP
+- [ ] Valider les performances
+- [ ] Documenter les limitations
+
+## Exemples de référence
+
+### Radio Paradise (source dynamique FIFO)
+
+**Fichier :** `pmoparadise/src/source.rs`
+
+**Points d'intérêt :**
+- Structure avec `Arc<RwLock<>>` pour l'état partagé
+- Callbacks sur playlists pour détecter les changements
+- Notifier injecté pour ContentDirectory
+- Adaptation des IDs playlist → Radio Paradise
+- Support de 4 canaux avec sous-containers
+
+**Schema d'Object ID :**
+```
+radio-paradise                                    # Racine
+radio-paradise:channel:{slug}                     # Canal (main, mellow, rock, eclectic)
+radio-paradise:channel:{slug}:live                # Stream live
+radio-paradise:channel:{slug}:liveplaylist        # Playlist live (queue)
+radio-paradise:channel:{slug}:liveplaylist:track:{pk}  # Track dans queue
+radio-paradise:channel:{slug}:history             # Historique
+radio-paradise:channel:{slug}:history:track:{pk}  # Track dans historique
+```
+
+### Qobuz (source catalogue avec playlists lazy)
+
+**Fichier :** `pmoqobuz/src/source.rs`
+
+**Points d'intérêt :**
+- `SourceCacheManager` centralisé
+- Cache lazy pour audio, eager pour covers
+- `LazyProvider` personnalisé
+- Playlists d'albums avec TTL (7 jours)
+- Adaptation IDs playlist → Qobuz
+- Navigation hiérarchique complexe (Discover, Genres, Favorites)
+
+**Schema d'Object ID :**
+```
+qobuz                                    # Racine
+qobuz:discover                           # Discover Catalog
+qobuz:discover:albums:ideal              # Albums (Ideal Discography)
+qobuz:discover:artists                   # Artistes Featured
+qobuz:genres                             # Discover Genres
+qobuz:genre:{id}                         # Genre spécifique
+qobuz:genre:{id}:new-releases            # Nouveautés du genre
+qobuz:favorites                          # My Music
+qobuz:favorites:albums                   # Albums favoris
+qobuz:album:{id}                         # Album spécifique
+qobuz:track:{id}                         # Track spécifique
+qobuz:playlist:{id}                      # Playlist spécifique
+qobuz:artist:{id}                        # Artiste spécifique
+```
+
+## Conseils d'implémentation
+
+### Performance
+
+1. **Cache agressif** : Utilisez `SourceCacheManager` pour tout
+2. **Pagination** : Limitez le nombre d'items retournés (max 100)
+3. **Lazy loading** : Ne chargez que ce qui est demandé
+4. **Rate limiting** : Respectez les limites API de la source
+5. **Arc<>** : Partagez les données coûteuses
+
+### Compatibilité UPnP
+
+1. **Genre obligatoire** : Certains clients (gupnp-av-cp) requièrent `<upnp:genre>`
+2. **URLs absolues** : Toujours retourner des URLs complètes (pas de chemins relatifs)
+3. **Protocol Info** : Utilisez `http-get:*:audio/flac:*` pour FLAC
+4. **Duration** : Format `H:MM:SS` (ex: `0:03:45`)
+5. **childCount** : Optionnel mais recommandé pour l'UI
+
+### Gestion d'erreurs
+
+1. **ObjectNotFound** : ID invalide
+2. **BrowseError** : Erreur générique de navigation
+3. **UriResolutionError** : Impossible de résoudre l'URI
+4. **PlaylistError** : Erreur d'interaction avec pmoplaylist
+5. **CacheError** : Erreur de cache
+
+### Thread Safety
+
+1. **Arc<RwLock<>>** : Pour l'état mutable partagé
+2. **tokio::sync::RwLock** : Pour l'async
+3. **Éviter Rc<>** : Pas thread-safe
+4. **Clone** : Implémentez `Clone` pour `Arc<>`
+
+## Conclusion
+
+L'implémentation d'une nouvelle `MusicSource` suit ces étapes :
+
+1. **Définir le schéma d'Object ID** : Hiérarchie claire et cohérente
+2. **Implémenter la navigation** : `browse()` pour tous les niveaux
+3. **Résoudre les URIs** : Cache local d'abord, puis original
+4. **Gérer le cache** : `SourceCacheManager` + `LazyProvider`
+5. **Adapter les IDs** : Playlist → Schema de la source
+6. **Notifier les changements** : `update_id` + callbacks
+
+Les exemples Radio Paradise et Qobuz couvrent les deux patterns principaux :
+- **Dynamique FIFO** : Radio Paradise
+- **Catalogue lazy** : Qobuz
+
+En suivant ces patterns, vous obtiendrez une source musicale performante, compatible UPnP, et bien intégrée dans l'écosystème PMOMusic.

Blackboard/Architecture/pmoserver_ext.md

@@ -0,0 +1,870 @@
+# Pattern d'extension PMOServer (`pmoserver_ext`)
+
+## Vue d'ensemble
+
+Le pattern `pmoserver_ext` permet d'étendre les fonctionnalités du serveur HTTP `pmoserver` de manière modulaire et découplée. Chaque crate spécialisée peut ajouter ses propres routes HTTP sans que `pmoserver` ne dépende de ces crates.
+
+**Principe** : Définir un trait d'extension que `pmoserver::Server` implémente via une feature Cargo.
+
+## Anatomie d'une extension
+
+### 1. Structure du module
+
+Créer un module `pmoserver_ext.rs` dans la crate :
+
+```rust
+// pmoXXX/src/pmoserver_ext.rs
+
+#[cfg(feature = "pmoserver")]
+use crate::{/* types internes de la crate */};
+#[cfg(feature = "pmoserver")]
+use async_trait::async_trait;
+#[cfg(feature = "pmoserver")]
+use axum::{Router, routing::get, Json, extract::{State, Path}};
+#[cfg(feature = "pmoserver")]
+use std::sync::Arc;
+```
+
+Déclarer le module dans `lib.rs` :
+
+```rust
+// pmoXXX/src/lib.rs
+#[cfg(feature = "pmoserver")]
+pub mod pmoserver_ext;
+
+#[cfg(feature = "pmoserver")]
+pub use pmoserver_ext::XXXExt;
+```
+
+Ajouter la feature dans `Cargo.toml` :
+
+```toml
+[features]
+pmoserver = ["dep:axum", "dep:async-trait"]
+
+[dependencies]
+axum = { version = "0.8", optional = true }
+async-trait = { version = "0.1", optional = true }
+pmoserver = { path = "../pmoserver" }
+```
+
+### 2. Définir le trait d'extension
+
+**Convention de nommage** : `{Domaine}Ext` avec méthodes préfixées `init_*`
+
+```rust
+/// Trait pour étendre pmoserver avec les fonctionnalités XXX
+#[cfg(feature = "pmoserver")]
+#[async_trait]
+pub trait XXXExt {
+    /// Initialise l'extension XXX et enregistre les routes HTTP
+    ///
+    /// # Arguments
+    /// * `param1` - Description du paramètre
+    ///
+    /// # Returns
+    /// Instance partagée de la ressource créée
+    ///
+    /// # Exemple
+    /// ```ignore
+    /// use pmoserver::ServerBuilder;
+    /// use pmoXXX::XXXExt;
+    ///
+    /// let mut server = ServerBuilder::new(...).build();
+    /// let resource = server.init_xxx(param1).await?;
+    /// ```
+    async fn init_xxx(&mut self, param1: String) -> anyhow::Result<Arc<Resource>>;
+}
+```
+
+### 3. Implémenter le trait
+
+Implémenter le trait pour `pmoserver::Server` :
+
+```rust
+#[cfg(feature = "pmoserver")]
+#[async_trait]
+impl XXXExt for pmoserver::Server {
+    async fn init_xxx(&mut self, param1: String) -> anyhow::Result<Arc<Resource>> {
+        // 1. Créer la ressource interne
+        let resource = Arc::new(Resource::new(param1)?);
+        
+        // 2. Créer l'état partagé pour les handlers
+        let state = XxxState::new(resource.clone());
+        
+        // 3. Créer le router avec les routes
+        let router = create_xxx_router(state);
+        
+        // 4. Enregistrer le router sur le serveur
+        self.add_router("/api/xxx", router).await;
+        
+        // 5. Retourner la ressource pour usage ultérieur
+        Ok(resource)
+    }
+}
+```
+
+### 4. État partagé (State)
+
+Créer une structure d'état cloneable pour les handlers :
+
+```rust
+/// État partagé pour les handlers XXX
+#[derive(Clone)]
+pub struct XxxState {
+    resource: Arc<Resource>,
+}
+
+impl XxxState {
+    pub fn new(resource: Arc<Resource>) -> Self {
+        Self { resource }
+    }
+}
+```
+
+### 5. Créer le router
+
+Définir les routes et handlers :
+
+```rust
+/// Crée le router pour l'API XXX
+fn create_xxx_router(state: XxxState) -> Router {
+    Router::new()
+        .route("/items", get(list_items).post(create_item))
+        .route("/items/{id}", get(get_item).delete(delete_item))
+        .with_state(state)
+}
+
+// Handlers
+async fn list_items(
+    State(state): State<XxxState>
+) -> Json<Vec<ItemSummary>> {
+    let items = state.resource.list_items();
+    Json(items)
+}
+
+async fn get_item(
+    State(state): State<XxxState>,
+    Path(id): Path<String>,
+) -> Result<Json<Item>, StatusCode> {
+    state.resource.get_item(&id)
+        .ok_or(StatusCode::NOT_FOUND)
+        .map(Json)
+}
+```
+
+## Méthodes disponibles du serveur
+
+`pmoserver::Server` expose ces méthodes pour enregistrer des routes :
+
+| Méthode | Usage |
+|---------|-------|
+| `add_handler(path, handler)` | Ajoute un handler simple sans état |
+| `add_handler_with_state(path, handler, state)` | Ajoute un handler avec état partagé |
+| `add_router(path, router)` | Monte un sous-router Axum |
+| `add_openapi(router, doc, tag)` | Enregistre une API avec documentation OpenAPI |
+| `add_spa::<W>(path)` | Sert une Single Page Application (RustEmbed) |
+| `base_url()` | Récupère l'URL de base du serveur |
+
+## Documentation OpenAPI avec utoipa
+
+La documentation OpenAPI est essentielle pour une extension `pmoserver`. Elle génère automatiquement une interface Swagger UI et documente les endpoints de l'API.
+
+### Configuration de base
+
+Ajouter `utoipa` dans `Cargo.toml` :
+
+```toml
+[dependencies]
+utoipa = { version = "5", features = ["axum_extras"] }
+serde = { version = "1", features = ["derive"] }
+```
+
+### 1. Définir les schémas de données
+
+Annoter les structures de réponse/requête avec `#[derive(ToSchema)]` :
+
+```rust
+use serde::{Serialize, Deserialize};
+use utoipa::ToSchema;
+
+/// Information sur un item
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct ItemInfo {
+    /// ID unique de l'item
+    #[schema(example = "item-123")]
+    pub id: String,
+    
+    /// Nom de l'item
+    #[schema(example = "Mon Item")]
+    pub name: String,
+    
+    /// Description optionnelle
+    #[schema(example = "Une description détaillée")]
+    pub description: Option<String>,
+    
+    /// Timestamp de création (millisecondes)
+    #[schema(example = 1234567890)]
+    pub created_at: u64,
+}
+
+/// Liste d'items
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct ItemList {
+    /// Nombre total d'items
+    pub total: usize,
+    
+    /// Items de la page courante
+    pub items: Vec<ItemInfo>,
+}
+
+/// Requête de création d'item
+#[derive(Debug, Clone, Deserialize, ToSchema)]
+pub struct CreateItemRequest {
+    /// Nom de l'item à créer
+    #[schema(example = "Nouvel Item")]
+    pub name: String,
+    
+    /// Description optionnelle
+    pub description: Option<String>,
+}
+
+/// Réponse d'erreur standard
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct ErrorResponse {
+    /// Message d'erreur
+    #[schema(example = "Item not found")]
+    pub error: String,
+}
+```
+
+**Points clés** :
+- `#[schema(example = "...")]` : Fournit des exemples pour la doc Swagger
+- Documenter chaque champ avec `///` pour apparaître dans l'API
+- Utiliser `Option<T>` pour les champs optionnels
+
+### 2. Annoter les handlers
+
+Utiliser `#[utoipa::path(...)]` pour documenter chaque endpoint :
+
+```rust
+/// GET /items - Liste tous les items
+#[utoipa::path(
+    get,
+    path = "/items",
+    params(
+        ("limit" = Option<u32>, Query, description = "Nombre max d'items à retourner"),
+        ("offset" = Option<u32>, Query, description = "Offset pour la pagination")
+    ),
+    responses(
+        (status = 200, description = "Liste des items", body = ItemList),
+        (status = 500, description = "Erreur serveur", body = ErrorResponse)
+    ),
+    tag = "items"
+)]
+async fn list_items(
+    State(state): State<XxxState>,
+    Query(params): Query<ListParams>,
+) -> Result<Json<ItemList>, (StatusCode, Json<ErrorResponse>)> {
+    let items = state.resource.list_items(params.limit, params.offset)
+        .map_err(|e| (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ErrorResponse { error: e.to_string() })
+        ))?;
+    
+    Ok(Json(ItemList {
+        total: items.len(),
+        items,
+    }))
+}
+
+/// GET /items/{id} - Récupère un item spécifique
+#[utoipa::path(
+    get,
+    path = "/items/{id}",
+    params(
+        ("id" = String, Path, description = "ID unique de l'item")
+    ),
+    responses(
+        (status = 200, description = "Item trouvé", body = ItemInfo),
+        (status = 404, description = "Item non trouvé", body = ErrorResponse),
+        (status = 500, description = "Erreur serveur", body = ErrorResponse)
+    ),
+    tag = "items"
+)]
+async fn get_item(
+    State(state): State<XxxState>,
+    Path(id): Path<String>,
+) -> Result<Json<ItemInfo>, (StatusCode, Json<ErrorResponse>)> {
+    state.resource.get_item(&id)
+        .ok_or_else(|| (
+            StatusCode::NOT_FOUND,
+            Json(ErrorResponse {
+                error: format!("Item {} not found", id)
+            })
+        ))
+        .map(Json)
+}
+
+/// POST /items - Crée un nouvel item
+#[utoipa::path(
+    post,
+    path = "/items",
+    request_body = CreateItemRequest,
+    responses(
+        (status = 201, description = "Item créé", body = ItemInfo),
+        (status = 400, description = "Requête invalide", body = ErrorResponse),
+        (status = 500, description = "Erreur serveur", body = ErrorResponse)
+    ),
+    tag = "items"
+)]
+async fn create_item(
+    State(state): State<XxxState>,
+    Json(req): Json<CreateItemRequest>,
+) -> Result<(StatusCode, Json<ItemInfo>), (StatusCode, Json<ErrorResponse>)> {
+    let item = state.resource.create_item(req.name, req.description)
+        .map_err(|e| (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ErrorResponse { error: e.to_string() })
+        ))?;
+    
+    Ok((StatusCode::CREATED, Json(item)))
+}
+
+/// DELETE /items/{id} - Supprime un item
+#[utoipa::path(
+    delete,
+    path = "/items/{id}",
+    params(
+        ("id" = String, Path, description = "ID unique de l'item")
+    ),
+    responses(
+        (status = 204, description = "Item supprimé"),
+        (status = 404, description = "Item non trouvé", body = ErrorResponse),
+        (status = 500, description = "Erreur serveur", body = ErrorResponse)
+    ),
+    tag = "items"
+)]
+async fn delete_item(
+    State(state): State<XxxState>,
+    Path(id): Path<String>,
+) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
+    state.resource.delete_item(&id)
+        .map_err(|e| (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ErrorResponse { error: e.to_string() })
+        ))?;
+    
+    Ok(StatusCode::NO_CONTENT)
+}
+```
+
+**Structure de `#[utoipa::path]`** :
+- **Méthode HTTP** : `get`, `post`, `put`, `delete`, `patch`
+- **`path`** : Chemin de l'endpoint (doit correspondre au router)
+- **`params`** : Paramètres Path ou Query avec description
+- **`request_body`** : Type du body pour POST/PUT
+- **`responses`** : Liste des réponses possibles avec codes HTTP
+- **`tag`** : Groupe d'endpoints dans Swagger UI
+
+### 3. Créer la structure OpenAPI
+
+Définir une structure avec `#[derive(OpenApi)]` :
+
+```rust
+use utoipa::OpenApi;
+
+/// Documentation OpenAPI pour l'API XXX
+#[derive(OpenApi)]
+#[openapi(
+    info(
+        title = "XXX API",
+        version = "1.0.0",
+        description = r#"
+# API REST pour XXX
+
+Cette API permet de gérer les items XXX avec les fonctionnalités suivantes :
+
+## Fonctionnalités
+
+- **CRUD complet** : Création, lecture, mise à jour et suppression d'items
+- **Pagination** : Support de limit/offset pour les listes
+- **Filtrage** : Recherche par critères multiples
+- **Validation** : Vérification automatique des données
+
+## Exemples d'utilisation
+
+### Lister les items
+```
+GET /api/xxx/items?limit=10&offset=0
+```
+
+### Créer un item
+```
+POST /api/xxx/items
+Content-Type: application/json
+
+{
+  "name": "Mon Item",
+  "description": "Description détaillée"
+}
+```
+
+### Récupérer un item
+```
+GET /api/xxx/items/item-123
+```
+
+### Supprimer un item
+```
+DELETE /api/xxx/items/item-123
+```
+        "#
+    ),
+    paths(
+        list_items,
+        get_item,
+        create_item,
+        delete_item,
+    ),
+    components(schemas(
+        ItemInfo,
+        ItemList,
+        CreateItemRequest,
+        ErrorResponse,
+    )),
+    tags(
+        (name = "items", description = "Opérations sur les items")
+    )
+)]
+pub struct ApiDoc;
+```
+
+**Sections importantes** :
+- **`info`** : Titre, version et description Markdown de l'API
+- **`paths`** : Liste des fonctions handler annotées
+- **`components(schemas(...))`** : Liste des structures `ToSchema`
+- **`tags`** : Organisation des endpoints en groupes
+
+### 4. Enregistrer l'API avec OpenAPI
+
+Dans l'implémentation du trait d'extension :
+
+```rust
+#[async_trait]
+impl XxxExt for pmoserver::Server {
+    async fn init_xxx(&mut self) -> anyhow::Result<Arc<Resource>> {
+        let resource = Arc::new(Resource::new()?);
+        let state = XxxState { resource: resource.clone() };
+        
+        // Créer le router avec les routes
+        let router = Router::new()
+            .route("/items", get(list_items).post(create_item))
+            .route("/items/{id}", get(get_item).delete(delete_item))
+            .with_state(state);
+        
+        // Enregistrer avec OpenAPI (génère aussi /swagger-ui/xxx)
+        let openapi = ApiDoc::openapi();
+        self.add_openapi(router, openapi, "xxx").await;
+        
+        Ok(resource)
+    }
+}
+```
+
+**Ce que fait `add_openapi`** :
+- Monte le router sur `/api/{tag}/`
+- Génère la spec OpenAPI JSON sur `/api/{tag}/openapi.json`
+- Crée une UI Swagger sur `/swagger-ui/{tag}/`
+
+### 5. Exemple complet : Radio Paradise
+
+**Extrait de** `pmoparadise/src/pmoserver_ext.rs:93-315`
+
+```rust
+/// Information sur un morceau
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct SongInfo {
+    /// Index dans le block
+    pub index: usize,
+    /// Artiste
+    pub artist: String,
+    /// Titre
+    pub title: String,
+    /// Album
+    pub album: String,
+    /// Année
+    pub year: Option<u32>,
+    /// Temps écoulé depuis le début du block (ms)
+    pub elapsed_ms: u64,
+    /// Durée du morceau (ms)
+    pub duration_ms: u64,
+    /// URL de la pochette
+    pub cover_url: Option<String>,
+}
+
+/// Réponse pour l'URL de streaming
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct StreamUrlResponse {
+    /// Event ID du block
+    #[schema(example = 1234567)]
+    pub event: u64,
+    /// URL de streaming FLAC
+    #[schema(example = "https://apps.radioparadise.com/blocks/chan/0/4/1234567-1234580.flac")]
+    pub stream_url: String,
+    /// Durée totale (ms)
+    #[schema(example = 900000)]
+    pub length_ms: u64,
+}
+
+/// GET /stream-url/{event_id} - Récupère l'URL de streaming
+#[utoipa::path(
+    get,
+    path = "/stream-url/{event_id}",
+    params(
+        ("event_id" = u64, Path, description = "Event ID du block"),
+        ("channel" = Option<u8>, Query, description = "Channel ID (0-3)")
+    ),
+    responses(
+        (status = 200, description = "URL de streaming", body = StreamUrlResponse),
+        (status = 500, description = "Erreur serveur")
+    ),
+    tag = "Radio Paradise"
+)]
+async fn get_stream_url(
+    State(state): State<RadioParadiseState>,
+    Path(event_id): Path<u64>,
+    Query(params): Query<ParadiseQuery>,
+) -> Result<Json<StreamUrlResponse>, StatusCode> {
+    let client = state.client_for_params(&params).await?;
+    let block = client.get_block(Some(event_id)).await.map_err(|e| {
+        tracing::error!("Failed to fetch block {}: {}", event_id, e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    Ok(Json(StreamUrlResponse {
+        event: block.event,
+        stream_url: block.url,
+        length_ms: block.length,
+    }))
+}
+
+#[derive(OpenApi)]
+#[openapi(
+    info(
+        title = "Radio Paradise API",
+        version = "1.0.0",
+        description = "API REST pour accéder aux métadonnées Radio Paradise"
+    ),
+    paths(
+        get_now_playing,
+        get_current_block,
+        get_stream_url,
+    ),
+    components(schemas(
+        SongInfo,
+        StreamUrlResponse,
+    )),
+    tags(
+        (name = "Radio Paradise", description = "Endpoints Radio Paradise")
+    )
+)]
+pub struct RadioParadiseApiDoc;
+```
+
+### Résultat : Interface Swagger
+
+Après avoir appelé `init_xxx()`, l'API est accessible :
+
+- **API JSON** : `http://localhost:8080/api/xxx/`
+- **Spec OpenAPI** : `http://localhost:8080/api/xxx/openapi.json`
+- **Swagger UI** : `http://localhost:8080/swagger-ui/xxx/`
+
+L'interface Swagger permet :
+- Parcourir tous les endpoints avec leur documentation
+- Tester les requêtes directement depuis le navigateur
+- Voir les schémas de données avec exemples
+- Consulter les codes de réponse HTTP possibles
+
+## Patterns courants
+
+### Pattern 1 : Extension simple avec router
+
+**Exemple** : `pmoparadise` (pmoparadise/src/pmoserver_ext.rs:367-392)
+
+```rust
+#[async_trait]
+impl RadioParadiseExt for pmoserver::Server {
+    async fn init_radioparadise(&mut self) -> anyhow::Result<State> {
+        let state = RadioParadiseState::new().await?;
+        
+        // Créer le router API
+        let api_router = create_api_router(state.clone());
+        
+        // Enregistrer avec OpenAPI
+        self.add_openapi(api_router, ApiDoc::openapi(), "radioparadise")
+            .await;
+        
+        Ok(state)
+    }
+}
+```
+
+### Pattern 2 : Extension avec cache et fichiers
+
+**Exemple** : `pmoaudiocache` (pmoaudiocache/src/lib.rs:225-260)
+
+```rust
+#[async_trait]
+impl AudioCacheExt for pmoserver::Server {
+    async fn init_audio_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> anyhow::Result<Arc<Cache>> {
+        let cache = Arc::new(new_cache(cache_dir, limit)?);
+        
+        // Router pour servir les fichiers FLAC
+        let file_router = create_file_router(cache.clone(), "audio/flac");
+        self.add_router("/", file_router).await;
+        
+        // API REST
+        let api_router = Router::new()
+            .route("/", get(list).post(add))
+            .route("/{pk}", get(get_info).delete(delete))
+            .with_state(cache.clone());
+        
+        self.add_openapi(api_router, ApiDoc::openapi(), "audio").await;
+        
+        Ok(cache)
+    }
+}
+```
+
+### Pattern 3 : Extension avec routes dynamiques
+
+**Exemple** : `pmomediaserver` (pmomediaserver/src/paradise_streaming.rs:70-148)
+
+```rust
+#[async_trait]
+impl ParadiseStreamingExt for pmoserver::Server {
+    async fn init_paradise_streaming(&mut self) -> Result<Arc<Manager>> {
+        // 1. Récupérer/créer les ressources partagées
+        let audio_cache = get_or_init_audio_cache(self).await?;
+        let manager = Arc::new(Manager::new(audio_cache).await?);
+        
+        // 2. Créer l'état partagé
+        let state = Arc::new(StreamingState { manager: manager.clone() });
+        
+        // 3. Enregistrer les routes pour chaque canal
+        for descriptor in ALL_CHANNELS.iter() {
+            let slug = descriptor.slug;
+            
+            // Route streaming FLAC
+            let path = format!("/stream/{}/flac", slug);
+            self.add_handler_with_state(
+                &path,
+                move |State(s): State<Arc<StreamingState>>| async move {
+                    stream_flac(s.manager.clone(), descriptor.id).await
+                },
+                state.clone(),
+            ).await;
+            
+            // Route streaming OGG
+            let path = format!("/stream/{}/ogg", slug);
+            self.add_handler_with_state(
+                &path,
+                move |State(s): State<Arc<StreamingState>>| async move {
+                    stream_ogg(s.manager.clone(), descriptor.id).await
+                },
+                state.clone(),
+            ).await;
+        }
+        
+        Ok(manager)
+    }
+}
+```
+
+## Gestion des opérations longues
+
+### Utiliser `spawn_blocking` pour le code synchrone
+
+Pour éviter de bloquer le runtime Tokio avec du code synchrone :
+
+```rust
+async fn list_renderers(
+    State(state): State<ControlPointState>
+) -> Json<Vec<Summary>> {
+    let control_point = state.control_point.clone();
+    
+    let summaries = tokio::task::spawn_blocking(move || {
+        let renderers = control_point.list_music_renderers();
+        renderers.into_iter()
+            .map(|r| Summary::from(&r))
+            .collect()
+    })
+    .await
+    .unwrap_or_default();
+    
+    Json(summaries)
+}
+```
+
+### Ajouter des timeouts pour les opérations réseau
+
+```rust
+const COMMAND_TIMEOUT: Duration = Duration::from_secs(5);
+
+async fn play_renderer(
+    State(state): State<ControlPointState>,
+    Path(id): Path<String>,
+) -> Result<Json<Response>, (StatusCode, Json<Error>)> {
+    let renderer = state.get_renderer(&id)
+        .ok_or((StatusCode::NOT_FOUND, Json(Error::not_found())))?;
+    
+    let play_task = tokio::task::spawn_blocking(move || renderer.play());
+    
+    time::timeout(COMMAND_TIMEOUT, play_task)
+        .await
+        .map_err(|_| (
+            StatusCode::GATEWAY_TIMEOUT,
+            Json(Error::timeout())
+        ))?
+        .map_err(|e| (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(Error::internal(e))
+        ))??;
+    
+    Ok(Json(Response::success()))
+}
+```
+
+### Utiliser `spawn` pour les tâches en arrière-plan
+
+Pour les opérations qui ne nécessitent pas d'attendre le résultat :
+
+```rust
+async fn trigger_action(
+    State(state): State<XxxState>,
+    Json(req): Json<Request>,
+) -> Json<Response> {
+    // Valider la requête
+    state.validate(&req)?;
+    
+    // Lancer l'action en arrière-plan
+    let state_clone = state.clone();
+    tokio::task::spawn(async move {
+        match state_clone.perform_action(req).await {
+            Ok(_) => debug!("Action completed"),
+            Err(e) => warn!("Action failed: {}", e),
+        }
+    });
+    
+    // Retourner immédiatement
+    Json(Response::accepted())
+}
+```
+
+## Checklist d'implémentation
+
+### Configuration de base
+- [ ] Créer le module `pmoserver_ext.rs` avec `#[cfg(feature = "pmoserver")]`
+- [ ] Ajouter la feature `pmoserver` dans `Cargo.toml` avec dépendances optionnelles
+- [ ] Re-exporter le trait dans `lib.rs`
+
+### Définition du trait
+- [ ] Définir le trait `{Domaine}Ext` avec méthode `init_*`
+- [ ] Créer la structure `{Domaine}State` avec `#[derive(Clone)]`
+- [ ] Implémenter le trait pour `pmoserver::Server`
+
+### Documentation OpenAPI
+- [ ] Ajouter `utoipa` dans les dépendances
+- [ ] Définir les schémas de réponse/requête avec `#[derive(ToSchema)]`
+- [ ] Ajouter des exemples avec `#[schema(example = "...")]`
+- [ ] Annoter chaque handler avec `#[utoipa::path(...)]`
+- [ ] Créer la structure `#[derive(OpenApi)]` avec documentation complète
+- [ ] Lister tous les paths et schemas dans `#[openapi(...)]`
+
+### Handlers et routes
+- [ ] Créer les handlers avec les extracteurs Axum appropriés
+- [ ] Gérer les erreurs avec des codes HTTP sémantiques
+- [ ] Créer le router et l'enregistrer avec `add_openapi()`
+- [ ] Ajouter des logs (debug, info, warn, error)
+
+### Performance et robustesse
+- [ ] Utiliser `spawn_blocking` pour le code synchrone
+- [ ] Ajouter des timeouts pour les opérations réseau
+- [ ] Utiliser `spawn` pour les tâches en arrière-plan si nécessaire
+
+## Exemple complet minimal
+
+```rust
+// pmoexample/src/pmoserver_ext.rs
+
+#[cfg(feature = "pmoserver")]
+use async_trait::async_trait;
+#[cfg(feature = "pmoserver")]
+use axum::{Router, routing::get, Json, extract::State};
+#[cfg(feature = "pmoserver")]
+use std::sync::Arc;
+#[cfg(feature = "pmoserver")]
+use crate::ExampleResource;
+
+#[cfg(feature = "pmoserver")]
+#[derive(Clone)]
+pub struct ExampleState {
+    resource: Arc<ExampleResource>,
+}
+
+#[cfg(feature = "pmoserver")]
+#[async_trait]
+pub trait ExampleExt {
+    async fn init_example(&mut self) -> anyhow::Result<Arc<ExampleResource>>;
+}
+
+#[cfg(feature = "pmoserver")]
+#[async_trait]
+impl ExampleExt for pmoserver::Server {
+    async fn init_example(&mut self) -> anyhow::Result<Arc<ExampleResource>> {
+        let resource = Arc::new(ExampleResource::new());
+        let state = ExampleState { resource: resource.clone() };
+        
+        let router = Router::new()
+            .route("/items", get(list_items))
+            .with_state(state);
+        
+        self.add_router("/api/example", router).await;
+        
+        Ok(resource)
+    }
+}
+
+#[cfg(feature = "pmoserver")]
+async fn list_items(State(state): State<ExampleState>) -> Json<Vec<String>> {
+    let items = state.resource.list();
+    Json(items)
+}
+```
+
+## Références
+
+### Exemples dans le codebase
+
+| Crate | Fichier | Pattern |
+|-------|---------|---------|
+| `pmoparadise` | `src/pmoserver_ext.rs:367-392` | Extension simple avec OpenAPI |
+| `pmoaudiocache` | `src/lib.rs:225-260` | Extension avec cache et fichiers |
+| `pmomediaserver` | `src/paradise_streaming.rs:70-148` | Extension avec routes dynamiques |
+| `pmocontrol` | `src/pmoserver_ext.rs:68-92` | Handlers avec `spawn_blocking` |
+| `pmoapp` | `src/lib.rs:145-165` | Extension SPA avec RustEmbed |
+
+### Dépendances communes
+
+- `axum` : Framework HTTP (Router, handlers, extracteurs)
+- `async-trait` : Support des traits async
+- `tokio` : Runtime async (spawn, spawn_blocking, timeout)
+- `anyhow` : Gestion d'erreurs pour init
+- `tracing` : Logging structuré
+- `utoipa` : Documentation OpenAPI/Swagger
+- `serde` : Sérialisation JSON

Blackboard/Architecture/webrenderer.md

@@ -0,0 +1,97 @@
+# WebRenderer UPnP privé par navigateur
+
+## Vue d'ensemble
+
+Le crate `pmowebrenderer` transforme chaque navigateur connecté en un **MediaRenderer UPnP privé**. Quand un navigateur se connecte via WebSocket, le backend Rust crée dynamiquement un device UPnP dédié. Le ControlPoint envoie des commandes SOAP à ce device, et les action handlers les relaient au navigateur via WebSocket. Le navigateur joue l'audio via `<audio>` et renvoie l'état au backend.
+
+## Architecture
+
+```
+Browser (Vue.js)               Rust Backend                    ControlPoint
+    |                              |                              |
+    |-- WS connect --------------->|                              |
+    |<-- SessionCreated (token) ---|                              |
+    |-- Init (capabilities) ------>|                              |
+    |                              |-- register_device() -------->| (Server)
+    |                              |   (Device + Services custom) |
+    |                              |-- push_renderer() ---------->| (CP registry)
+    |                              |                              |
+    |                              |<-- SOAP Play (control_handler)
+    |<-- Command(Play, uri) -------|   (action handler -> WS)     |
+    |-- StateUpdate(Playing) ----->|                              |
+    |                              |-- update StateVarInstance -->| (evented -> SSE)
+    |                              |                              |
+    |-- WS disconnect ------------>|                              |
+    |                              |-- device_says_byebye() ----->| (CP registry)
+```
+
+## Flux de connexion
+
+1. Le navigateur ouvre une WebSocket vers `/api/webrenderer/ws`
+2. Il envoie un message `Init` avec ses capabilities (user_agent, formats supportes)
+3. Le backend construit un `Device` UPnP avec des `Service` models custom :
+   - AVTransport (Play, Stop, Pause, Seek, SetURI, GetPositionInfo, etc.)
+   - RenderingControl (SetVolume, GetVolume, SetMute, GetMute)
+   - ConnectionManager (GetProtocolInfo)
+4. Chaque Action a un handler qui capture le `mpsc::UnboundedSender<ServerMessage>` du WS
+5. Le device est enregistre via `Server::register_device()` (routes SOAP + DEVICE_REGISTRY)
+6. Un `RendererInfo` est pousse dans le `DeviceRegistry` du ControlPoint via `push_renderer()`
+7. Le backend renvoie un `SessionCreated` avec le token et les infos du renderer
+
+## Decision cle : Services dynamiques (zero changement pmoupnp)
+
+Plutot que de modifier pmoupnp pour permettre l'override de handlers post-creation, on **construit des `Service` models dynamiques** pour chaque session WebSocket :
+
+- Les `StateVariable` statics de pmomediarenderer sont reutilisees via `Arc::clone(&*VAR)`
+- De nouvelles `Action` sont creees avec `Action::new()`, configurees avec `set_handler()` puis wrappees en `Arc`
+- Les handlers capturent le sender WS et le `SharedState` (clone a chaque appel via `Fn` closure)
+- Le `Device` est construit avec ces services custom, puis enregistre normalement
+
+Cela reutilise toute l'infrastructure existante sans modification de pmoupnp ni pmomediarenderer.
+
+## Propagation d'etat bidirectionnelle
+
+### SOAP -> Navigateur (commandes)
+Les action handlers des services AVTransport/RenderingControl :
+1. Lisent les arguments SOAP depuis `ActionData` via la macro `get!()`
+2. Envoient un `ServerMessage::Command` ou `SetVolume`/`SetMute` via le canal mpsc
+3. Mettent a jour le `SharedState` local
+4. Retournent les arguments OUT via `set!()` si necessaire
+
+### Navigateur -> UPnP (etats)
+Quand le navigateur envoie `StateUpdate`, `PositionUpdate`, `MetadataUpdate` ou `VolumeUpdate` :
+1. Le `SharedState` est mis a jour
+2. Les `StateVarInstance` du `DeviceInstance` sont mises a jour via `set_value(StateValue::...)`
+3. Les variables evented declenchent les notifications UPnP captees par le watcher du ControlPoint
+
+## Cycle de vie
+
+- **Connexion** : creation du Device, enregistrement aupres du Server et du ControlPoint
+- **Session active** : le `SessionManager` gere un timeout de 30 minutes d'inactivite
+- **Deconnexion WS** : appel a `device_says_byebye()` sur le registry du ControlPoint pour marquer offline
+- **Cleanup automatique** : le `SessionManager` verifie toutes les 60 secondes les sessions expirees
+- **Pas de SSDP** : les WebRenderers sont injectes directement, max_age de 86400s
+
+## Structure des fichiers
+
+| Fichier | Role |
+|---------|------|
+| `handlers.rs` | Action handlers SOAP->WS (play, stop, pause, seek, set_uri, get_*_info, volume, mute) |
+| `renderer.rs` | `WebRendererFactory` : construction dynamique Device/Services avec handlers |
+| `websocket.rs` | Handler WS : connexion, reception messages, creation device, propagation etat |
+| `session.rs` | `SessionManager` : gestion des sessions avec timeout |
+| `config.rs` | `WebRendererExt` trait pour `pmoserver::Server` (enregistrement route WS) |
+| `messages.rs` | Types de messages WS (ServerMessage, ClientMessage, etc.) |
+| `state.rs` | `RendererState` et `SharedState` (etat partage entre handlers et WS) |
+| `error.rs` | Types d'erreur du crate |
+| `lib.rs` | Exports publics |
+
+## Points d'attention
+
+1. **parking_lot::RwLockWriteGuard non-Send** : les guards de `SharedState` doivent etre dropes avant tout `.await` dans les handlers async. Utiliser des blocs `{ ... }` pour limiter la portee.
+
+2. **Fn vs FnOnce** : les `ActionHandler` sont `Fn` (appeles plusieurs fois). Les closures doivent cloner `ws` et `state` a chaque appel, avant le `async move`.
+
+3. **Routes Axum persistantes** : Axum ne supporte pas la suppression de routes. Les routes SOAP d'un device deconnecte persistent mais les handlers retournent des erreurs naturellement.
+
+4. **Acces au Server** : le WebSocket handler utilise `pmoserver::get_server()` (singleton global) pour enregistrer les devices dynamiquement.

Blackboard/Done/Bug_lecture_open_home.md

@@ -0,0 +1,82 @@
+# Bug : Duplication de piste en position 0 lors de la lecture
+
+**Statut** : Terminé  
+**Crate** : pmocontrol
+
+---
+
+## Description initiale du bug
+
+### Contexte
+Lecture d'une playlist liée (bindée) à une queue OpenHome ou interne.
+
+### Comportement observé
+1. Sélection d'une playlist → la queue se charge correctement
+2. Lecture démarre à la piste 1 → OK
+3. Fin de la piste 1 → passage à la piste 2
+4. **BUG** : Après un certain délai (~60s), la piste 2 est **dupliquée en position 0**
+5. La lecture continue depuis cette nouvelle position 0
+
+### Symptôme clé
+Toute piste en cours de lecture finit par être dupliquée en première position de la queue.
+
+---
+
+## Analyse et cause racine
+
+### Mécanisme du bug
+La fonction `sync_queue` (appelée lors des refreshes périodiques de playlist toutes les 60 secondes) comparait les items **uniquement par leur URI**. 
+
+Si le MediaServer retournait une URI légèrement différente pour le même morceau (tokens de session, encodage différent, etc.), l'item courant n'était pas reconnu dans la nouvelle playlist et était préservé en position 0, créant une duplication.
+
+### Flux problématique
+```
+1. Playlist attachée → lecture piste N
+2. Refresh périodique (60s) → sync_queue()
+3. Comparaison URI courante vs URIs playlist
+4. URI non trouvée → piste préservée en position 0
+5. Résultat : duplication
+```
+
+---
+
+## Solution implémentée
+
+### Principe
+Extension de la logique de comparaison pour utiliser l'URI **OU** le `didl_id` comme critère d'identification. Le `didl_id` est l'identifiant DIDL-Lite stable assigné par le MediaServer, indépendant de l'URI de streaming.
+
+### Fichiers modifiés
+
+| Fichier | Modifications |
+|---------|---------------|
+| `pmocontrol/src/queue/interne.rs` | Comparaison par `didl_id` en fallback + logs diagnostic |
+| `pmocontrol/src/queue/openhome.rs` | Fonction `items_match` + modification `sync_queue` et `lcs_flags` |
+
+### Code clé
+
+```rust
+// pmocontrol/src/queue/openhome.rs
+fn items_match(a: &PlaybackItem, b: &PlaybackItem) -> bool {
+    a.uri == b.uri || a.didl_id == b.didl_id
+}
+```
+
+```rust
+// pmocontrol/src/queue/interne.rs
+let new_idx = items.iter().position(|item| item.uri == current_uri)
+    .or_else(|| items.iter().position(|item| item.didl_id == current_didl_id));
+```
+
+---
+
+## Diagnostic
+
+Pour activer les logs :
+
+```bash
+RUST_LOG=pmocontrol::queue=debug
+```
+
+Messages de trace :
+- `sync_queue: current item found in new playlist` → Comportement normal
+- `sync_queue: current item NOT found in new playlist` → Cas problématique (ne devrait plus apparaître)

Blackboard/Done/Frontend_Review.md

@@ -0,0 +1,651 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+## Vue d'ensemble
+
+Le frontend de PMOMusic est une application Vue 3 + TypeScript avec Pinia, organisée autour
+de composables réactifs, d'un client SSE centralisé et d'un cache API à plusieurs niveaux.
+L'architecture générale est solide : séparation claire composables/services/vues, typage strict
+(`strict: true` dans `tsconfig.app.json`), reconnexion SSE avec backoff exponentiel.
+
+Cette revue documente les bugs avérés, les fragilités de conception et les axes d'amélioration
+relevés lors d'une lecture complète des fichiers `pmoapp/webapp/src/`.
+
+---
+
+## Bugs
+
+### 1. `apiCache.ts:130-133` — Mutation globale du TTL non réentrante
+
+**Problème** : la méthode `fetch()` accepte un `ttl` optionnel par appel. Pour l'appliquer,
+elle modifie `this.options.ttl` globalement avant d'appeler `this.set()`, puis le restaure :
+
+```typescript
+// apiCache.ts:130-133
+if (ttl) {
+  const originalTtl = this.options.ttl;
+  this.options.ttl = ttl;          // (A) modification globale
+  this.set(endpoint, data, params);
+  this.options.ttl = originalTtl;  // (B) restauration
+}
+```
+
+**Cause** : `fetcher()` est `await`-é (ligne 128) avant ce bloc. Pendant cet await, d'autres
+microtasks peuvent s'intercaler et appeler `isFresh()` ou `set()`, qui lisent `this.options.ttl`.
+Si deux appels `fetch()` avec des `ttl` différents sont en vol simultanément, la restauration
+de (B) peut effacer la valeur posée par le second appel concurrent, ou (A) peut lire un TTL
+modifié par un autre appel.
+
+**Solution** : passer le `ttl` directement à `set()` comme paramètre, sans modifier l'état
+partagé :
+
+```typescript
+// Dans set() : ajouter un paramètre ttl optionnel
+set<T>(endpoint: string, data: T, params?: ..., etag?: string, ttl?: number): void {
+  const key = this.makeKey(endpoint, params);
+  this.cache.set(key, {
+    data,
+    timestamp: Date.now(),
+    ttl: ttl ?? this.options.ttl,  // TTL par entrée, pas global
+    etag,
+  });
+  this.notifySubscribers(key, data);
+}
+
+// Dans isFresh() : lire le ttl de l'entrée
+private isFresh(key: string): boolean {
+  const entry = this.cache.get(key);
+  if (!entry) return false;
+  return Date.now() - entry.timestamp < (entry.ttl ?? this.options.ttl);
+}
+
+// Dans fetch() : supprimer le bloc de mutation globale
+this.set(endpoint, data, params, undefined, ttl);
+```
+
+---
+
+### 2. `useRenderers.ts:151 + 222` — Réassignation post-switch écrase le nouvel objet
+
+**Problème** : le handler `onRendererEvent` termine par une ligne inconditionnelle :
+
+```typescript
+// useRenderers.ts:222
+snapshotState.snapshots.set(rendererId, snapshot);
+```
+
+Cette ligne s'exécute pour **tous** les types d'événements après le `switch`, y compris pour
+`position_changed` et `metadata_changed` qui ont déjà créé et stocké un nouvel objet dans le
+Map à l'intérieur du switch :
+
+```typescript
+// position_changed — ligne 151 : stocke newSnapshot
+snapshotState.snapshots.set(rendererId, newSnapshot);
+break;
+// → puis ligne 222 écrase avec snapshot (proxy d'origine)
+
+// metadata_changed — ligne 176 : stocke un spread
+snapshotState.snapshots.set(rendererId, { ...snapshot, state: { ...snapshot.state } });
+break;
+// → puis ligne 222 écrase avec snapshot (proxy d'origine)
+```
+
+**Cause** : `break` sort du `switch` mais pas de la fonction. La ligne 222 est atteinte dans
+tous les cas.
+
+**Conséquence** : les objets créés pour forcer la détection de changement par Vue sont
+immédiatement écrasés. Le mécanisme de réactivité fonctionne malgré tout (le proxy muté est
+re-stocké), mais la logique est trompeuse et fragile : si Vue venait à optimiser la détection
+d'identité des objets réactifs, cette redondance deviendrait un bug visible.
+
+**Solution** : supprimer la ligne 222 et s'assurer que chaque branche du switch stocke
+explicitement son résultat dans la Map. Les branches `volume_changed`, `mute_changed` et
+`binding_changed` qui mutent directement `snapshot` doivent aussi créer un nouvel objet :
+
+```typescript
+case "volume_changed":
+  snapshotState.snapshots.set(rendererId, {
+    ...snapshot,
+    state: { ...snapshot.state, volume: event.volume },
+  });
+  break;
+
+case "mute_changed":
+  snapshotState.snapshots.set(rendererId, {
+    ...snapshot,
+    state: { ...snapshot.state, mute: event.mute },
+  });
+  break;
+// idem pour binding_changed, stream_state_changed
+```
+
+Supprimer la ligne 222. Chaque case devient responsable de son stockage, ce qui élimine aussi
+le besoin de `toRaw()`.
+
+---
+
+### 3. `useRenderers.ts:122` — `as any` sur `transport_state`
+
+**Problème** :
+
+```typescript
+// useRenderers.ts:122
+snapshot.state.transport_state = event.state as any;
+```
+
+**Cause** : `event.state` est typé `string` (type SSE générique), alors que
+`transport_state` est une union littérale (`"PLAYING" | "PAUSED" | "STOPPED" | ...`).
+Le cast `as any` contourne la vérification de type.
+
+**Conséquence** : si le backend envoie une valeur non prévue (ex. `"TRANSITIONING"`), elle
+sera stockée sans validation. Les composants qui comparent `transport_state === "PLAYING"`
+ne matcheront pas et l'UI restera muette.
+
+**Solution** : définir un guard de type ou une assertion dans `types.ts` :
+
+```typescript
+// services/pmocontrol/types.ts
+export type TransportState = "PLAYING" | "PAUSED" | "STOPPED" | "NO_MEDIA" | "TRANSITIONING";
+
+export function isTransportState(s: string): s is TransportState {
+  return ["PLAYING", "PAUSED", "STOPPED", "NO_MEDIA", "TRANSITIONING"].includes(s);
+}
+```
+
+```typescript
+// useRenderers.ts — case state_changed
+case "state_changed":
+  if (isTransportState(event.state)) {
+    snapshot.state.transport_state = event.state;
+  } else {
+    console.warn(`[useRenderers] transport_state inconnu: ${event.state}`);
+  }
+  break;
+```
+
+---
+
+### 4. `apiCache.ts:181-200` — `invalidate()` supprime silencieusement les subscriptions actives
+
+**Problème** :
+
+```typescript
+// apiCache.ts:197-200
+keysToDelete.forEach(key => {
+  this.cache.delete(key);
+  this.subscriptions.delete(key);  // ← subscriptions perdues sans notification
+});
+```
+
+**Cause** : lors d'une invalidation (ex. après un SSE event), les callbacks enregistrés via
+`subscribe()` sont supprimés de la Map. Les composants ne sont pas notifiés de la suppression
+et ne reçoivent plus les futures mises à jour même après un refetch.
+
+**Conséquence** : un composant qui a appelé `apiCache.subscribe(...)` et qui survit à une
+invalidation devient « sourd » sans le savoir.
+
+**Solution** : conserver les subscriptions lors d'une invalidation — seule la donnée en cache
+est périmée, pas les abonnés :
+
+```typescript
+invalidate(pattern: string): void {
+  const keysToDelete: string[] = [];
+  // ... construction de keysToDelete inchangée ...
+  keysToDelete.forEach(key => {
+    this.cache.delete(key);
+    // NE PAS supprimer this.subscriptions.get(key)
+    // Les abonnés seront notifiés lors du prochain set()
+  });
+}
+```
+
+Si l'on veut notifier les abonnés d'une invalidation (pour qu'ils affichent un état de
+chargement), ajouter un callback optionnel `onInvalidate` dans l'interface de subscription.
+
+---
+
+## Fragilités de conception
+
+### 5. `useRenderers.ts:7,143-151` — `toRaw()` comme contournement de réactivité Vue
+
+**Problème** : le code utilise `toRaw()` pour extraire l'objet brut d'un proxy Vue avant de
+faire un spread, afin que la copie ne contienne pas de getters réactifs qui pointent vers
+l'objet original :
+
+```typescript
+// useRenderers.ts:143-151
+const rawState = toRaw(snapshot.state);
+const newState = { ...rawState };
+const newSnapshot = { ...snapshot, state: newState };
+snapshotState.snapshots.set(rendererId, newSnapshot);
+```
+
+**Cause** : les Maps imbriquées dans un objet `reactive()` ont un comportement de réactivité
+peu prévisible dans Vue 3. Vue ne détecte pas les mutations d'éléments d'une Map réactive si
+la référence de la Map elle-même ne change pas.
+
+**Solution recommandée** : remplacer `reactive(new Map())` par `shallowRef(new Map())` pour
+les Maps qui contiennent des données complexes. La réactivité se déclenche en remplaçant la
+Map entière (ou en forçant un `triggerRef`) :
+
+```typescript
+// Au lieu de :
+const snapshotState = reactive<RendererSnapshotState>({ snapshots: reactive(new Map()), ... });
+
+// Utiliser :
+const snapshots = shallowRef(new Map<string, FullRendererSnapshot>());
+
+// Pour déclencher la réactivité après mutation :
+snapshots.value = new Map(snapshots.value);  // ou triggerRef(snapshots)
+```
+
+Cela rend la propagation de réactivité explicite et élimine le besoin de `toRaw()`.
+
+---
+
+### 6. `useRenderers.ts:552-570` — Timer de debounce non nettoyé dans `useRenderer()`
+
+**Problème** : `useRenderer()` crée un timer de debounce local qui n'est jamais nettoyé si
+le composant parent est démonté :
+
+```typescript
+// useRenderers.ts:553-566
+let refreshDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+const REFRESH_DEBOUNCE_MS = 500;
+
+async function refresh(force = true) {
+  if (refreshDebounceTimer !== null) return;
+  refreshDebounceTimer = setTimeout(() => {
+    refreshDebounceTimer = null;
+  }, REFRESH_DEBOUNCE_MS);
+  await Promise.all([...]);
+}
+```
+
+**Cause** : pas d'appel à `clearTimeout` dans un `onUnmounted`. Si le composant est démonté
+pendant les 500 ms du debounce, le timer continue de s'exécuter.
+
+**Conséquence** : fuite mémoire potentielle ; dans des cas extrêmes (navigation rapide), le
+callback peut tenter de déclencher un fetch sur un composant déjà démonté.
+
+**Solution** :
+
+```typescript
+import { onUnmounted } from 'vue';
+
+// Dans useRenderer() :
+onUnmounted(() => {
+  if (refreshDebounceTimer !== null) {
+    clearTimeout(refreshDebounceTimer);
+    refreshDebounceTimer = null;
+  }
+});
+```
+
+---
+
+### 7. `useRenderers.ts:45-46` — Singleton SSE initialisé par flag de module non réinitialisable
+
+**Problème** :
+
+```typescript
+// useRenderers.ts:45-46
+let sseInitialized = false;
+function ensureSSEInitialized() {
+  if (sseInitialized) return;
+  // ...
+  sseInitialized = true;
+}
+```
+
+**Cause** : ce flag de module est persistant pour toute la durée de vie de la page. Si la
+connexion SSE est perdue puis rétablie avec un nouvel objet `PMOControlSSE`, le handler
+`onRendererEvent` précédent peut ne plus être actif, mais `sseInitialized` empêche sa
+re-enregistration.
+
+**Conséquence** : après une déconnexion et reconnexion SSE, les événements renderer peuvent
+ne plus être reçus par `useRenderers` jusqu'à un rechargement de page.
+
+**Solution** : exposer une fonction `resetSSE()` qui remet `sseInitialized = false` et la
+connecter à l'événement de reconnexion du service SSE. Alternativement, utiliser le pattern
+`provide/inject` ou un store Pinia pour gérer le cycle de vie SSE explicitement, en lieu et
+place du flag de module.
+
+---
+
+## Qualité du code
+
+### 8. `useTabs.ts` — Deep watch déclenchant une sérialisation localStorage à chaque mutation
+
+**Problème** : le watch qui persiste l'état des onglets utilise `{ deep: true }` sur un
+tableau qui peut contenir jusqu'à 12 entrées avec des métadonnées :
+
+```typescript
+// useTabs.ts:349-355
+watch(
+  () => [state.tabs, state.activeTabId, state.tabHistory],
+  () => { saveToLocalStorage(); },
+  { deep: true },
+);
+```
+
+**Cause** : `{ deep: true }` traverse récursivement toutes les propriétés observées.
+`saveToLocalStorage()` appelle `JSON.stringify` sur l'ensemble des tabs à chaque mutation,
+même mineure (ex. changement de `activeTabId`).
+
+**Solution** : surveiller les propriétés individuellement et sérialiser uniquement ce qui
+change, ou utiliser un computed pour construire la clé de changement :
+
+```typescript
+// Watch séparés, sans deep
+watch(() => state.activeTabId, saveToLocalStorage);
+watch(() => state.tabHistory.length, saveToLocalStorage);
+watch(
+  () => state.tabs.map(t => t.id + t.type + (t.metadata?.rendererId ?? '')).join('|'),
+  saveToLocalStorage,
+);
+```
+
+---
+
+### 9. `UnifiedControlView.vue:40-49` — Swipe : `clientX` final au lieu de la position initiale
+
+**Problème** :
+
+```typescript
+// UnifiedControlView.vue:40-49
+useSwipe(viewRef, {
+  threshold: 50,
+  onSwipeEnd(_e: TouchEvent, swipeDirection: string) {
+    if (swipeDirection === "right" && !drawerOpen.value) {
+      const touch = _e.changedTouches[0];
+      if (touch && touch.clientX < 50) {  // ← position finale du doigt
+        drawerOpen.value = true;
+      }
+    }
+  },
+});
+```
+
+**Cause** : `onSwipeEnd` reçoit l'événement `touchend`. Dans `changedTouches`, `clientX`
+est la position **finale** du doigt (après le swipe), pas la position initiale. Un swipe
+commençant à `x=30` et terminant à `x=150` a `clientX=150` dans `touchend` — la condition
+`< 50` ne sera jamais vraie pour un swipe horizontal significatif.
+
+**Conséquence** : le geste de swipe depuis le bord gauche ne fonctionne probablement pas
+sur les appareils tactiles.
+
+**Solution** : capturer la position initiale dans `onSwipeStart` :
+
+```typescript
+const swipeStartX = ref(0);
+
+useSwipe(viewRef, {
+  threshold: 50,
+  onSwipeStart(e: TouchEvent) {
+    swipeStartX.value = e.touches[0]?.clientX ?? 0;
+  },
+  onSwipeEnd(_e: TouchEvent, swipeDirection: string) {
+    if (swipeDirection === "right" && !drawerOpen.value && swipeStartX.value < 50) {
+      drawerOpen.value = true;
+    }
+  },
+});
+```
+
+---
+
+### 10. `api.ts:50` — Réponse JSON non validée avant le cast TypeScript
+
+**Problème** :
+
+```typescript
+// api.ts:50
+return response.json();  // retour typé T par inférence, sans validation
+```
+
+**Cause** : `response.json()` retourne `Promise<any>`. TypeScript accepte le retour car la
+méthode `request<T>` promet `Promise<T>`, mais aucune validation de structure n'est effectuée.
+
+**Conséquence** : si le backend renvoie un schéma légèrement différent (champ renommé, type
+changé), le bug se manifestera loin du point d'appel avec un message cryptique. En
+développement avec plusieurs instances en parallèle (`udn_prefix` différent), une requête
+dirigée vers la mauvaise instance peut retourner un format inattendu.
+
+**Solution pragmatique** : ajouter une validation légère avec un type guard pour les réponses
+critiques, ou au minimum loguer la réponse brute en mode développement :
+
+```typescript
+private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
+  // ...
+  const data = await response.json();
+  if (import.meta.env.DEV && data == null) {
+    console.warn(`[PMOControlAPI] Réponse vide pour ${path}`);
+  }
+  return data as T;
+}
+```
+
+Pour les endpoints critiques (`getRendererFullSnapshot`, `getRenderers`), envisager un
+schéma de validation Zod ou une assertion runtime minimale.
+
+---
+
+## Accessibilité et feedback utilisateur
+
+### 11. Absence de labels ARIA sur les contrôles transport
+
+Les composants `TransportControls.vue` et `VolumeControl.vue` contiennent des boutons
+iconiques (play, pause, stop, volume) sans attributs `aria-label`. Les lecteurs d'écran
+ne peuvent pas identifier la fonction de ces contrôles.
+
+**Correction minimale** :
+
+```html
+<!-- TransportControls.vue -->
+<button @click="play" aria-label="Lecture">
+  <PlayIcon />
+</button>
+<button @click="pause" aria-label="Pause">
+  <PauseIcon />
+</button>
+```
+
+---
+
+### 12. Erreurs réseau silencieuses sans feedback utilisateur
+
+Plusieurs appels critiques sont lancés en fire-and-forget sans propagation vers l'UI :
+
+```typescript
+// useRenderers.ts:86
+void fetchRenderers(true);   // erreur loggée en console uniquement
+
+// useRenderers.ts:89
+void fetchRendererSnapshot(rendererId, { force: true });  // idem
+```
+
+Le store `ui.ts` dispose d'un système de notifications toast (`addNotification`). Les erreurs
+de réseau devraient y être propagées pour informer l'utilisateur :
+
+```typescript
+import { useUIStore } from '@/stores/ui';
+
+const uiStore = useUIStore();
+
+// Dans le handler SSE :
+try {
+  await fetchRenderers(true);
+} catch {
+  uiStore.addNotification({
+    message: 'Impossible de rafraîchir la liste des renderers',
+    type: 'error',
+  });
+}
+```
+
+---
+
+## Points forts à conserver
+
+Ces patterns sont bien conçus et ne doivent pas être modifiés dans les corrections ci-dessus :
+
+- **Déduplication des requêtes en vol** (`apiCache.ts:100-112`) : évite les appels réseau
+  redondants quand plusieurs composants demandent la même ressource simultanément.
+- **Watch sélectif sur les IDs** (`UnifiedControlView.vue:139-150`) : calcule une clé
+  synthétique `ids.join(',')` au lieu d'un deep watch sur le tableau de renderers.
+- **Backoff exponentiel SSE** (`sse.ts`) : reconnexion progressive 1s→2s→4s→8s→16s→30s
+  avec cap. Implémentation robuste.
+- **Fetch batch contrôlé** (`useRenderers.ts:351-383`) : `fetchBatchSnapshots()` avec
+  concurrence limitée (défaut 3) et délai inter-batches. Évite de saturer le réseau au
+  démarrage.
+- **`filterRenderers` par UDN** (`UnifiedControlView.vue:107-120`) : filtre les WebRenderers
+  étrangers en comparant le UDN normalisé. Logique correcte avec gestion du préfixe `uuid:`.
+
+---
+
+## État d'avancement — corrections appliquées (commit 2026-04-06)
+
+Les 12 points de la revue ont été traités. Le tableau ci-dessous récapitule ce qui a été
+fait et ce qui reste à finir.
+
+| # | Problème | État |
+|---|----------|------|
+| 1 | `apiCache` — TTL mutation globale | ✅ Corrigé (`ttl` par entrée dans `CacheEntry`, `isFresh()` lit `entry.ttl`) |
+| 2 | `useRenderers` — double réassignation post-switch | ✅ Corrigé (chaque `case` responsable, ligne 222 supprimée) |
+| 3 | `useRenderers` — `as any` sur `transport_state` | ✅ Corrigé (`isTransportState` guard dans `types.ts`) |
+| 4 | `apiCache` — `invalidate()` détruisait les subscriptions | ✅ Corrigé (`this.subscriptions.delete` supprimé) |
+| 5 | `useRenderers` — `toRaw()` / `reactive(Map)` fragile | ✅ Migré vers `shallowRef` + helpers `triggerSnapshotReactivity()` / `triggerLoadingReactivity()` |
+| 6 | `useRenderer()` — timer debounce non nettoyé | ✅ Corrigé (`onUnmounted` + `clearTimeout`) |
+| 7 | Singleton SSE non réinitialisable | ✅ Corrigé (`resetSSE()` exposé dans le retour de `useRenderers()`) |
+| 8 | `useTabs` — deep watch coûteux | ✅ Corrigé (watches séparés sans `deep: true`) |
+| 9 | Swipe — `clientX` final au lieu d'initial | ✅ Corrigé (`swipeStartX` capturé dans `onSwipeStart`) |
+| 10 | `api.ts` — JSON non validé | ✅ Corrigé (log dev-mode pour réponse nulle) |
+| 11 | Absence de labels ARIA | ✅ Corrigé (4 boutons transport + bouton mute + slider volume) |
+| 12 | Erreurs réseau silencieuses | ✅ Corrigé (`uiStore.notifyError()` dans `fetchRenderers` et `fetchRendererSnapshot`) |
+
+---
+
+## Tâches restantes — ✅ Toutes corrigées (commit 2026-04-06)
+
+| # | Problème résiduel | État |
+|---|-------------------|------|
+| A | `state_changed` — mutation directe sans trigger réactivité | ✅ Corrigé (spread + `triggerSnapshotReactivity()`) |
+| B | `queue_refreshing`/`queue_updated` — `queueRefreshingIds` sans trigger | ✅ Corrigé (`triggerQueueReactivity()` ajoutée et appelée) |
+| C | `toRaw` import obsolète, `position_changed` simplifié | ✅ Corrigé (`toRaw` supprimé de l'import, spread direct) |
+
+---
+
+### A. `useRenderers.ts` — `state_changed` : mutation directe sans déclenchement de réactivité
+
+**Problème** : avec la migration vers `shallowRef`, les objets dans la Map ne sont plus des
+proxies Vue. La mutation directe de `snapshot.state.transport_state` ne déclenche aucune
+réactivité — les composants ne se mettront pas à jour quand l'état de transport change :
+
+```typescript
+// useRenderers.ts — case state_changed (code actuel)
+case "state_changed":
+  if (isTransportState(event.state)) {
+    snapshot.state.transport_state = event.state;  // ← mutation directe, pas de trigger
+  }
+  break;
+```
+
+**Solution** : créer un nouvel objet, comme pour `volume_changed` et `mute_changed` :
+
+```typescript
+case "state_changed":
+  if (isTransportState(event.state)) {
+    snapshots.value.set(rendererId, {
+      ...snapshot,
+      state: { ...snapshot.state, transport_state: event.state },
+    });
+  } else {
+    console.warn(`[useRenderers] transport_state inconnu: ${event.state}`);
+  }
+  break;
+```
+
+---
+
+### B. `useRenderers.ts` — `queue_refreshing` / `queue_updated` : mutations de `queueRefreshingIds` sans trigger
+
+**Problème** : `queueRefreshingIds` est un `shallowRef<Set>`. Les appels `.add()` et
+`.delete()` sur `.value` ne déclenchent pas la réactivité de `shallowRef` :
+
+```typescript
+// useRenderers.ts — case queue_refreshing (code actuel)
+case "queue_refreshing":
+  queueRefreshingIds.value.add(rendererId);   // ← pas de trigger
+  break;
+
+case "queue_updated":
+  queueRefreshingIds.value.delete(rendererId); // ← pas de trigger
+  break;
+```
+
+Le composable `isQueueRefreshing(id)` retourne `queueRefreshingIds.value.has(id)`. Sans
+trigger, les templates qui dépendent de cette valeur ne se recalculeront pas.
+
+**Solution** : ajouter une fonction `triggerQueueReactivity()` analogue à
+`triggerLoadingReactivity()` et l'appeler après chaque mutation :
+
+```typescript
+function triggerQueueReactivity() {
+  queueRefreshingIds.value = new Set(queueRefreshingIds.value);
+}
+
+// Dans le switch :
+case "queue_refreshing":
+  queueRefreshingIds.value.add(rendererId);
+  triggerQueueReactivity();
+  break;
+
+case "queue_updated":
+  snapshot.state.queue_len = event.queue_length;
+  queueRefreshingIds.value.delete(rendererId);
+  triggerQueueReactivity();
+  void fetchRendererSnapshot(rendererId, { force: true });
+  break;
+```
+
+---
+
+### C. `useRenderers.ts` — import `toRaw` et commentaire obsolètes
+
+**Problème** : avec `shallowRef`, les objets stockés dans `snapshots.value` sont de simples
+objets JavaScript (jamais des proxies Vue). L'appel `toRaw(snapshot.state)` dans
+`position_changed` est devenu un no-op, et le commentaire qui le justifie est trompeur :
+
+```typescript
+// useRenderers.ts:160-163 (commentaire et import obsolètes)
+// IMPORTANT: Utiliser toRaw() pour obtenir l'objet brut non-réactif avant de copier
+// sinon Vue copie les getters réactifs qui continuent à pointer vers l'objet d'origine
+const rawState = toRaw(snapshot.state);
+const newState = { ...rawState };
+```
+
+**Solution** : supprimer le `toRaw()`, simplifier en spread direct, retirer `toRaw` de
+l'import ligne 7 :
+
+```typescript
+// Remplacer :
+import { ref, shallowRef, computed, toRaw, type Ref, onUnmounted } from "vue";
+
+// Par :
+import { ref, shallowRef, computed, type Ref, onUnmounted } from "vue";
+
+// Dans position_changed :
+const newSnapshot = {
+  ...snapshot,
+  state: {
+    ...snapshot.state,
+    position_ms: positionMs ?? 0,
+    duration_ms: durationMs,
+  },
+};
+snapshots.value.set(rendererId, newSnapshot);
+```
+
+Cette simplification rend aussi le cas `position_changed` cohérent avec les autres cases
+(`volume_changed`, `mute_changed`, etc.) qui construisent directement l'objet final sans
+passer par une variable intermédiaire.

Blackboard/Done/Pinnable_cache_item.md

@@ -0,0 +1,905 @@
+# Rapport Final : Items Épinglables et TTL dans PMOcache
+
+## Objectif de la tâche
+
+Étendre le système de cache PMOcache pour permettre un contrôle plus fin des règles de suppression des items. L'objectif était double :
+
+1. **Phase 1** : Implémenter un système d'items épinglables (pinned) protégés de l'éviction LRU, avec support du TTL (Time To Live) pour l'expiration automatique
+2. **Phase 2** : Exposer ces fonctionnalités via une API REST complète avec documentation OpenAPI
+
+## Contexte
+
+La crate PMOcache implémente un système de cache avec :
+- Capacité maximale configurable
+- Politique d'éviction LRU (Least Recently Used)
+- TTL optionnel pour les items
+
+La nouvelle fonctionnalité permet de :
+- **Épingler** des items critiques pour les rendre permanents
+- **Exclure** les items épinglés du comptage de la limite du cache
+- **Définir un TTL** pour supprimer automatiquement les items temporaires
+- **Garantir l'incompatibilité** entre pinning et TTL (règle métier)
+
+## Architecture de la solution
+
+### 1. Modifications de la base de données
+
+#### Schéma SQL étendu
+
+```sql
+CREATE TABLE IF NOT EXISTS asset (
+    pk TEXT PRIMARY KEY,
+    collection TEXT,
+    id TEXT,
+    hits INTEGER DEFAULT 0,
+    last_used TEXT,
+    lazy_pk TEXT,
+    pinned INTEGER DEFAULT 0 CHECK (pinned IN (0, 1)),
+    ttl_expires_at TEXT
+)
+```
+
+Deux nouvelles colonnes :
+- **`pinned`** : Booléen (0/1) indiquant si l'item est protégé
+- **`ttl_expires_at`** : Date RFC3339 d'expiration (optionnel)
+
+#### Structure `CacheEntry` enrichie
+
+```rust
+pub struct CacheEntry {
+    pub pk: String,
+    pub lazy_pk: Option<String>,
+    pub id: Option<String>,
+    pub collection: Option<String>,
+    pub hits: i32,
+    pub last_used: Option<String>,
+    pub pinned: bool,                    // Nouveau
+    pub ttl_expires_at: Option<String>,  // Nouveau
+    pub metadata: Option<Value>,
+}
+```
+
+### 2. API de base de données (db.rs)
+
+#### Nouvelles méthodes implémentées
+
+##### Gestion du comptage
+- **`count_unpinned()`** : Compte uniquement les items non épinglés
+  - Les items épinglés sont exclus de la limite du cache
+
+##### Gestion du pinning
+- **`pin(pk)`** : Épingle un item
+  - Vérifie qu'aucun TTL n'est défini (règle métier)
+  - Retourne erreur si TTL présent
+  
+- **`unpin(pk)`** : Désépingle un item
+
+- **`is_pinned(pk)`** : Vérifie le statut de pinning
+
+##### Gestion du TTL
+- **`set_ttl(pk, expires_at)`** : Définit la date d'expiration
+  - Vérifie que l'item n'est pas épinglé (règle métier)
+  - Retourne erreur si épinglé
+  
+- **`clear_ttl(pk)`** : Supprime le TTL
+
+- **`get_expired()`** : Récupère tous les items expirés
+
+##### Modification de `get_oldest()`
+
+Exclusion automatique des items épinglés :
+
+```sql
+SELECT ... FROM asset
+WHERE pinned = 0
+ORDER BY last_used ASC, hits ASC
+LIMIT ?1
+```
+
+### 3. Logique du cache (cache.rs)
+
+#### Méthodes publiques exposées
+
+```rust
+pub async fn pin(&self, pk: &str) -> Result<()>
+pub async fn unpin(&self, pk: &str) -> Result<()>
+pub async fn is_pinned(&self, pk: &str) -> Result<bool>
+pub async fn set_ttl(&self, pk: &str, expires_at: &str) -> Result<()>
+pub async fn clear_ttl(&self, pk: &str) -> Result<()>
+```
+
+#### Politique d'éviction améliorée
+
+La méthode `enforce_limit()` a été complètement repensée :
+
+```rust
+pub async fn enforce_limit(&self) -> Result<usize> {
+    // 1. Supprimer d'abord les items expirés (TTL dépassé)
+    let expired_entries = self.db.get_expired()?;
+    for entry in expired_entries {
+        // Suppression fichiers + DB
+    }
+
+    // 2. Compter UNIQUEMENT les items non épinglés
+    let count = self.db.count_unpinned()?;
+
+    // 3. Si limite dépassée, supprimer les plus vieux (non épinglés)
+    if count > self.limit {
+        let to_remove = count - self.limit;
+        let old_entries = self.db.get_oldest(to_remove)?;
+        // Suppression...
+    }
+}
+```
+
+**Ordre de priorité** :
+1. Items expirés (TTL) → suppression immédiate
+2. Items non épinglés les plus vieux (LRU) → suppression si limite dépassée
+3. Items épinglés → **jamais supprimés automatiquement**
+
+### 4. API REST (api.rs)
+
+#### Nouvelles structures de données
+
+```rust
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct PinStatus {
+    pub pk: String,
+    pub pinned: bool,
+    pub ttl_expires_at: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct PinResponse {
+    pub pk: String,
+    pub message: String,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct SetTtlRequest {
+    pub expires_at: String,  // RFC3339
+}
+```
+
+#### Handlers HTTP implémentés
+
+##### `get_pin_status(pk)` - GET /{pk}/pin
+Récupère le statut actuel de pinning et TTL d'un item.
+
+**Réponse 200 OK** :
+```json
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "pinned": false,
+  "ttl_expires_at": null
+}
+```
+
+##### `pin_item(pk)` - POST /{pk}/pin
+Épingle un item pour le protéger de l'éviction.
+
+**Réponse 200 OK** :
+```json
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "message": "Item '1a2b3c4d5e6f7a8b' pinned successfully"
+}
+```
+
+**Réponse 409 CONFLICT** (si TTL défini) :
+```json
+{
+  "error": "CONFLICT",
+  "message": "Cannot pin an item with TTL set. Clear TTL first."
+}
+```
+
+##### `unpin_item(pk)` - DELETE /{pk}/pin
+Désépingle un item.
+
+##### `set_item_ttl(pk, request)` - POST /{pk}/ttl
+Définit le TTL d'un item.
+
+**Requête** :
+```json
+{
+  "expires_at": "2025-01-20T10:30:00Z"
+}
+```
+
+**Réponse 409 CONFLICT** (si épinglé) :
+```json
+{
+  "error": "CONFLICT",
+  "message": "Cannot set TTL on a pinned item. Unpin first."
+}
+```
+
+**Réponse 400 BAD REQUEST** (format invalide) :
+```json
+{
+  "error": "INVALID_DATE",
+  "message": "Invalid RFC3339 date format"
+}
+```
+
+##### `clear_item_ttl(pk)` - DELETE /{pk}/ttl
+Supprime le TTL d'un item.
+
+### 5. Routes HTTP (pmoserver_ext.rs)
+
+Routes ajoutées au router API :
+
+```rust
+Router::new()
+    // ... routes existantes ...
+    .route(
+        "/{pk}/pin",
+        get(api::get_pin_status::<C>)
+            .post(api::pin_item::<C>)
+            .delete(api::unpin_item::<C>),
+    )
+    .route(
+        "/{pk}/ttl",
+        post(api::set_item_ttl::<C>)
+            .delete(api::clear_item_ttl::<C>),
+    )
+```
+
+**URLs complètes** (exemple pour cache audio) :
+- `GET /api/audio/{pk}/pin`
+- `POST /api/audio/{pk}/pin`
+- `DELETE /api/audio/{pk}/pin`
+- `POST /api/audio/{pk}/ttl`
+- `DELETE /api/audio/{pk}/ttl`
+
+### 6. Documentation OpenAPI (openapi.rs)
+
+La macro `create_cache_openapi!` a été enrichie pour inclure automatiquement :
+
+```rust
+#[openapi(
+    paths(
+        // ... paths existants ...
+        $crate::api::get_pin_status::<Self>,
+        $crate::api::pin_item::<Self>,
+        $crate::api::unpin_item::<Self>,
+        $crate::api::set_item_ttl::<Self>,
+        $crate::api::clear_item_ttl::<Self>,
+    ),
+    components(
+        schemas(
+            // ... schemas existants ...
+            $crate::api::PinStatus,
+            $crate::api::PinResponse,
+            $crate::api::SetTtlRequest,
+        )
+    ),
+)]
+```
+
+**Accès Swagger UI** : `/swagger-ui/{cache_name}`
+
+## Règles métier implémentées
+
+### 1. Incompatibilité stricte : Pinned ↔ TTL
+
+Un item ne peut **jamais** être à la fois épinglé ET avoir un TTL :
+
+| État actuel | Action | Résultat |
+|-------------|--------|----------|
+| Aucun TTL | `pin()` | ✅ Succès |
+| TTL défini | `pin()` | ❌ Erreur 409 |
+| Non épinglé | `set_ttl()` | ✅ Succès |
+| Épinglé | `set_ttl()` | ❌ Erreur 409 |
+
+**Rationale** :
+- **Épinglé** = permanent, ne doit jamais être supprimé automatiquement
+- **TTL** = temporaire, sera supprimé à expiration
+- Ces deux concepts sont sémantiquement contradictoires
+
+### 2. Exclusion du comptage
+
+Les items épinglés ne comptent **pas** dans la limite du cache :
+
+```rust
+// Cache avec limite de 100 items
+let unpinned_count = cache.db.count_unpinned()?;  // 100
+let total_count = cache.db.count()?;              // 150
+
+// Le cache peut contenir :
+// - 100 items non épinglés (limite respectée)
+// - 50 items épinglés (hors limite)
+```
+
+### 3. Protection absolue contre l'éviction
+
+Les items épinglés sont **jamais** retournés par `get_oldest()` :
+
+```sql
+-- Requête LRU exclut automatiquement les épinglés
+SELECT ... FROM asset
+WHERE pinned = 0  -- ← Filtre explicite
+ORDER BY last_used ASC
+```
+
+## Tests et validation
+
+### Suite de tests dédiée (test_pinnable.rs)
+
+9 tests couvrant tous les cas d'usage :
+
+1. **`test_pin_unpin`** : Épinglage/désépinglage basique
+2. **`test_pinned_excluded_from_lru`** : Items épinglés protégés de l'éviction
+3. **`test_pinned_count_separately`** : Comptage séparé des items
+4. **`test_cannot_pin_with_ttl`** : Règle métier TTL → pas de pin
+5. **`test_cannot_set_ttl_when_pinned`** : Règle métier pin → pas de TTL
+6. **`test_ttl_expiration`** : Suppression automatique des items expirés
+7. **`test_clear_ttl`** : Suppression du TTL
+8. **`test_get_expired`** : Récupération des items expirés
+9. **`test_cache_entry_fields`** : Vérification des champs dans les entrées
+
+**Résultat** : ✅ 9/9 tests passent
+
+### Tests de non-régression
+
+Tous les tests existants de `test_cache.rs` passent sans modification :
+- Test de création de cache
+- Test d'ajout de fichiers
+- Test de déduplication
+- Test de collections
+- Test de suppression
+- Test d'éviction LRU
+- Test de purge
+- Test de consolidation
+
+**Résultat** : ✅ Aucune régression détectée
+
+### Compilation
+
+```bash
+cargo build -p pmocache
+```
+
+**Résultat** : ✅ Compilation sans erreur ni warning
+
+## Compatibilité et migration
+
+### Rétrocompatibilité de la base de données
+
+**Aucune migration manuelle requise**. Les colonnes ont des valeurs par défaut :
+
+```sql
+pinned INTEGER DEFAULT 0         -- Non épinglé par défaut
+ttl_expires_at TEXT              -- NULL par défaut
+```
+
+Les bases existantes sont automatiquement compatibles :
+- Tous les items existants sont non épinglés
+- Aucun TTL défini par défaut
+- Le comportement LRU standard reste identique
+
+### Rétrocompatibilité du code
+
+Toutes les méthodes existantes continuent de fonctionner :
+- `add_from_url()`, `add_from_file()`, `get()`, etc.
+- Pas de changement de signature
+- Comportement LRU identique pour les items non épinglés
+
+## Documentation API REST
+
+### Tableau récapitulatif des endpoints
+
+| Méthode | Route | Description | Codes retour |
+|---------|-------|-------------|--------------|
+| `GET` | `/{pk}/pin` | Récupère le statut de pinning | 200, 404 |
+| `POST` | `/{pk}/pin` | Épingle un item | 200, 404, 409 |
+| `DELETE` | `/{pk}/pin` | Désépingle un item | 200, 404 |
+| `POST` | `/{pk}/ttl` | Définit le TTL | 200, 400, 404, 409 |
+| `DELETE` | `/{pk}/ttl` | Supprime le TTL | 200, 404 |
+
+### Codes de statut HTTP
+
+| Code | Signification | Quand ? |
+|------|--------------|---------|
+| `200` | Succès | Opération réussie |
+| `400` | Requête invalide | Format de date TTL incorrect |
+| `404` | Non trouvé | PK inexistant dans le cache |
+| `409` | Conflit | Violation de règle métier (pin+TTL) |
+| `500` | Erreur serveur | Erreur de base de données |
+
+### Structure des erreurs
+
+Format cohérent pour toutes les erreurs :
+
+```json
+{
+  "error": "CODE_ERREUR",
+  "message": "Description lisible pour l'utilisateur"
+}
+```
+
+Exemples :
+- `"CONFLICT"` : Violation de règle métier
+- `"NOT_FOUND"` : Item inexistant
+- `"INVALID_DATE"` : Format de date RFC3339 invalide
+- `"PIN_ERROR"` / `"TTL_ERROR"` : Erreur technique
+
+## Exemples d'utilisation
+
+### Utilisation programmatique (Rust)
+
+```rust
+use pmocache::{Cache, CacheConfig};
+use chrono::{Duration, Utc};
+
+// Créer un cache
+let cache = Cache::<MyConfig>::new("./cache", 100)?;
+
+// Ajouter un fichier
+let pk = cache.add_from_url("https://example.com/file.dat", None).await?;
+
+// ═══════════════════════════════════════
+// Scénario 1 : Item permanent (épinglé)
+// ═══════════════════════════════════════
+cache.pin(&pk).await?;
+
+// Vérifier le statut
+assert!(cache.is_pinned(&pk).await?);
+
+// L'item ne sera JAMAIS supprimé automatiquement
+// même si le cache est plein
+
+// ═══════════════════════════════════════
+// Scénario 2 : Item temporaire (TTL)
+// ═══════════════════════════════════════
+let pk2 = cache.add_from_url("https://example.com/temp.dat", None).await?;
+
+// Définir une expiration dans 24h
+let expires_at = (Utc::now() + Duration::hours(24)).to_rfc3339();
+cache.set_ttl(&pk2, &expires_at).await?;
+
+// L'item sera automatiquement supprimé après 24h
+// lors du prochain appel à enforce_limit()
+
+// ═══════════════════════════════════════
+// Scénario 3 : Conversion épinglé → TTL
+// ═══════════════════════════════════════
+cache.unpin(&pk).await?;  // Désépingler d'abord
+cache.set_ttl(&pk, &expires_at).await?;  // OK maintenant
+```
+
+### Utilisation via API REST
+
+#### Workflow complet : Épingler un fichier important
+
+```bash
+# 1. Ajouter un fichier au cache
+curl -X POST http://localhost:8080/api/audio/ \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://example.com/important.flac"}'
+
+# Réponse :
+# {
+#   "pk": "abc123def456",
+#   "url": "https://example.com/important.flac",
+#   "message": "Item added successfully"
+# }
+
+# 2. Vérifier le statut actuel
+curl http://localhost:8080/api/audio/abc123def456/pin
+
+# Réponse :
+# {
+#   "pk": "abc123def456",
+#   "pinned": false,
+#   "ttl_expires_at": null
+# }
+
+# 3. Épingler le fichier
+curl -X POST http://localhost:8080/api/audio/abc123def456/pin
+
+# Réponse :
+# {
+#   "pk": "abc123def456",
+#   "message": "Item 'abc123def456' pinned successfully"
+# }
+
+# 4. Vérifier qu'il est épinglé
+curl http://localhost:8080/api/audio/abc123def456/pin
+
+# Réponse :
+# {
+#   "pk": "abc123def456",
+#   "pinned": true,
+#   "ttl_expires_at": null
+# }
+```
+
+#### Workflow : Fichier temporaire avec TTL
+
+```bash
+# 1. Ajouter un fichier
+curl -X POST http://localhost:8080/api/audio/ \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://example.com/preview.flac"}'
+
+# Réponse : {"pk": "xyz789abc123", ...}
+
+# 2. Définir un TTL de 1 heure
+curl -X POST http://localhost:8080/api/audio/xyz789abc123/ttl \
+  -H "Content-Type: application/json" \
+  -d '{"expires_at": "2025-01-15T11:30:00Z"}'
+
+# Réponse :
+# {
+#   "pk": "xyz789abc123",
+#   "message": "TTL set successfully for item 'xyz789abc123'"
+# }
+
+# 3. Le fichier sera automatiquement supprimé après expiration
+```
+
+#### Gestion d'erreur : Conflit de règle métier
+
+```bash
+# 1. Épingler un item
+curl -X POST http://localhost:8080/api/audio/abc123/pin
+# OK
+
+# 2. Essayer de définir un TTL (interdit)
+curl -X POST http://localhost:8080/api/audio/abc123/ttl \
+  -H "Content-Type: application/json" \
+  -d '{"expires_at": "2025-01-15T12:00:00Z"}'
+
+# Réponse 409 CONFLICT :
+# {
+#   "error": "CONFLICT",
+#   "message": "Cannot set TTL on a pinned item. Unpin first."
+# }
+
+# 3. Solution : désépingler puis définir TTL
+curl -X DELETE http://localhost:8080/api/audio/abc123/pin
+curl -X POST http://localhost:8080/api/audio/abc123/ttl \
+  -H "Content-Type: application/json" \
+  -d '{"expires_at": "2025-01-15T12:00:00Z"}'
+# OK
+```
+
+## Fichiers modifiés
+
+### Phase 1 : Implémentation de base
+
+1. **`pmocache/src/db.rs`** (380 lignes ajoutées)
+   - Modification du schéma SQL (colonnes `pinned`, `ttl_expires_at`)
+   - Ajout de champs dans `CacheEntry`
+   - 8 nouvelles méthodes : `count_unpinned()`, `pin()`, `unpin()`, `is_pinned()`, `set_ttl()`, `clear_ttl()`, `get_expired()`
+   - Modification de `get_oldest()` pour exclure les items épinglés
+   - Mise à jour de toutes les requêtes SELECT
+
+2. **`pmocache/src/cache.rs`** (135 lignes ajoutées)
+   - 5 nouvelles méthodes publiques : `pin()`, `unpin()`, `is_pinned()`, `set_ttl()`, `clear_ttl()`
+   - Refonte complète de `enforce_limit()` :
+     - Suppression prioritaire des items expirés
+     - Utilisation de `count_unpinned()`
+     - Protection des items épinglés
+
+3. **`pmocache/tests/test_pinnable.rs`** (280 lignes, nouveau fichier)
+   - 9 tests exhaustifs
+   - Couverture complète des cas d'usage
+   - Validation des règles métier
+
+### Phase 2 : Enrichissement API REST
+
+4. **`pmocache/src/api.rs`** (230 lignes ajoutées)
+   - 3 nouvelles structures : `SetTtlRequest`, `PinResponse`, `PinStatus`
+   - 5 nouveaux handlers HTTP avec gestion d'erreurs complète
+   - Validation des règles métier au niveau HTTP
+   - Codes de statut appropriés (200, 400, 404, 409, 500)
+
+5. **`pmocache/src/pmoserver_ext.rs`** (15 lignes modifiées)
+   - 2 nouvelles routes dans `create_api_router()` :
+     - `/{pk}/pin` (GET, POST, DELETE)
+     - `/{pk}/ttl` (POST, DELETE)
+   - Documentation des routes mise à jour
+
+6. **`pmocache/src/openapi.rs`** (10 lignes modifiées)
+   - Macro `create_cache_openapi!` enrichie
+   - 5 nouveaux endpoints documentés
+   - 3 nouveaux schémas de données
+
+7. **`pmocache/src/lib.rs`** (5 lignes modifiées)
+   - Export des structures publiques pour l'API
+
+**Total** : 7 fichiers modifiés, ~1055 lignes de code ajoutées
+
+## Avantages de la solution
+
+### 1. Architecture propre et extensible
+
+- **Séparation des responsabilités** :
+  - `db.rs` : logique de base de données
+  - `cache.rs` : logique métier
+  - `api.rs` : interface HTTP
+  
+- **Réutilisabilité** :
+  - Traits existants conservés
+  - Pas de duplication de code
+  - Pattern cohérent avec l'architecture PMOcache
+
+### 2. Sécurité et fiabilité
+
+- **Règles métier strictes** :
+  - Incompatibilité TTL ↔ Pinned appliquée à tous les niveaux
+  - Validation au niveau DB, cache ET API
+  
+- **Gestion d'erreurs robuste** :
+  - Codes HTTP sémantiques
+  - Messages explicites
+  - Pas d'état incohérent possible
+
+### 3. Performance
+
+- **Requêtes SQL optimisées** :
+  - Index sur `pinned` pour requêtes rapides
+  - `WHERE pinned = 0` évite le scan complet
+  
+- **Comptage efficace** :
+  - `count_unpinned()` utilise un index
+  - Pas de post-filtrage en mémoire
+
+### 4. Expérience développeur
+
+- **API intuitive** :
+  - Méthodes async cohérentes avec l'existant
+  - Nommage clair (`pin()`, `unpin()`, `set_ttl()`)
+  
+- **Documentation complète** :
+  - OpenAPI générée automatiquement
+  - Swagger UI interactive
+  - Exemples d'utilisation
+
+### 5. Compatibilité
+
+- **Migration transparente** :
+  - Aucune intervention manuelle
+  - Valeurs par défaut appropriées
+  
+- **Pas de breaking change** :
+  - API existante inchangée
+  - Nouveaux champs optionnels dans `CacheEntry`
+
+## Cas d'usage concrets
+
+### 1. Cache de couvertures d'albums
+
+```rust
+// Épingler les couvertures des albums favoris
+for album in user.favorite_albums {
+    let cover_pk = covers_cache.get_cover_pk(&album.id).await?;
+    covers_cache.pin(&cover_pk).await?;
+}
+
+// → Les couvertures favorites restent toujours en cache
+// → Même si le cache se remplit de nouvelles couvertures
+```
+
+### 2. Cache audio avec previews temporaires
+
+```rust
+// Pistes complètes : épinglées si dans la playlist courante
+for track in current_playlist.tracks {
+    audio_cache.pin(&track.pk).await?;
+}
+
+// Previews de 30 secondes : TTL de 1 heure
+let preview_pk = audio_cache.add_preview(&track_url).await?;
+let expires_at = (Utc::now() + Duration::hours(1)).to_rfc3339();
+audio_cache.set_ttl(&preview_pk, &expires_at).await?;
+
+// → Pistes courantes toujours disponibles
+// → Previews nettoyées automatiquement
+```
+
+### 3. Cache de métadonnées avec rafraîchissement
+
+```rust
+// Métadonnées d'album : TTL de 24h pour forcer le rafraîchissement
+let metadata_pk = metadata_cache.add_metadata(&album).await?;
+let tomorrow = (Utc::now() + Duration::days(1)).to_rfc3339();
+metadata_cache.set_ttl(&metadata_pk, &tomorrow).await?;
+
+// → Métadonnées rafraîchies quotidiennement
+// → Pas de données obsolètes
+```
+
+## Limitations et considérations
+
+### 1. Pas de limite sur les items épinglés
+
+Les items épinglés peuvent s'accumuler indéfiniment. Recommandations :
+
+```rust
+// Surveiller le nombre d'items épinglés
+let pinned_count = cache.db.count()? - cache.db.count_unpinned()?;
+if pinned_count > MAX_PINNED_ITEMS {
+    warn!("Too many pinned items: {}", pinned_count);
+}
+```
+
+### 2. TTL vérifié uniquement lors de `enforce_limit()`
+
+Les items expirés ne sont pas supprimés immédiatement. Solutions possibles :
+
+```rust
+// Option 1 : Appel périodique
+tokio::spawn(async move {
+    loop {
+        tokio::time::sleep(Duration::from_secs(3600)).await;
+        cache.enforce_limit().await?;
+    }
+});
+
+// Option 2 : Vérification à l'accès
+if let Ok(entry) = cache.db.get(&pk, false) {
+    if let Some(ttl) = entry.ttl_expires_at {
+        if Utc::now() > DateTime::parse_from_rfc3339(&ttl)? {
+            cache.delete_item(&pk).await?;
+        }
+    }
+}
+```
+
+### 3. Format de date RFC3339 strict
+
+L'API exige le format RFC3339. Exemples valides :
+
+```
+2025-01-15T10:30:00Z           ✅ UTC
+2025-01-15T10:30:00+01:00      ✅ Avec timezone
+2025-01-15T10:30:00.123Z       ✅ Avec millisecondes
+2025-01-15 10:30:00            ❌ Format invalide
+```
+
+## Évolutions futures possibles
+
+### 1. Gestion automatique du TTL
+
+Implémenter un worker en arrière-plan :
+
+```rust
+pub async fn start_ttl_worker(&self) {
+    tokio::spawn(async move {
+        loop {
+            self.enforce_limit().await;
+            tokio::time::sleep(Duration::from_secs(60)).await;
+        }
+    });
+}
+```
+
+### 2. Pinning conditionnel
+
+Épingler automatiquement selon des critères :
+
+```rust
+pub async fn pin_if<F>(&self, predicate: F) -> Result<Vec<String>>
+where
+    F: Fn(&CacheEntry) -> bool,
+{
+    let entries = self.db.get_all(false)?;
+    let mut pinned = Vec::new();
+    
+    for entry in entries {
+        if predicate(&entry) && !entry.pinned {
+            self.pin(&entry.pk).await?;
+            pinned.push(entry.pk);
+        }
+    }
+    
+    Ok(pinned)
+}
+
+// Utilisation
+cache.pin_if(|e| e.hits > 100).await?;  // Épingler les plus utilisés
+```
+
+### 3. TTL relatif
+
+Faciliter la définition de TTL :
+
+```rust
+pub async fn set_ttl_relative(&self, pk: &str, duration: Duration) -> Result<()> {
+    let expires_at = (Utc::now() + duration).to_rfc3339();
+    self.set_ttl(pk, &expires_at).await
+}
+
+// Utilisation
+cache.set_ttl_relative(&pk, Duration::hours(24)).await?;
+```
+
+### 4. Statistiques de pinning
+
+```rust
+pub async fn get_pinning_stats(&self) -> Result<PinningStats> {
+    Ok(PinningStats {
+        total_items: self.db.count()?,
+        pinned_items: self.db.count()? - self.db.count_unpinned()?,
+        items_with_ttl: self.db.count_with_ttl()?,
+        expired_items: self.db.get_expired()?.len(),
+    })
+}
+```
+
+## Résultats et métriques
+
+### Tests
+
+| Catégorie | Tests | Passés | Taux |
+|-----------|-------|--------|------|
+| Nouveaux tests | 9 | 9 | 100% |
+| Tests existants | 15 | 15 | 100% |
+| **Total** | **24** | **24** | **100%** |
+
+### Code
+
+| Métrique | Valeur |
+|----------|--------|
+| Fichiers modifiés | 7 |
+| Lignes ajoutées | ~1055 |
+| Nouvelles méthodes DB | 8 |
+| Nouvelles méthodes Cache | 5 |
+| Nouveaux endpoints API | 5 |
+| Nouvelles structures | 3 |
+
+### Compilation
+
+- ✅ Aucune erreur
+- ✅ Aucun warning
+- ✅ Toutes les features compilent
+
+## Conclusion
+
+L'implémentation des items épinglables et du TTL dans PMOcache est **complète et production-ready**. La solution répond à tous les objectifs initiaux :
+
+### ✅ Objectifs atteints
+
+1. **Items épinglables fonctionnels** :
+   - Protection absolue contre l'éviction LRU
+   - Exclusion du comptage de la limite du cache
+   
+2. **Système de TTL robuste** :
+   - Expiration automatique des items temporaires
+   - Suppression prioritaire lors de l'éviction
+   
+3. **Règle métier stricte** :
+   - Incompatibilité TTL ↔ Pinned garantie à tous les niveaux
+   - Validation DB, cache et API
+   
+4. **API REST complète** :
+   - 5 nouveaux endpoints documentés
+   - Gestion d'erreurs cohérente
+   - Documentation OpenAPI automatique
+   
+5. **Compatibilité préservée** :
+   - Migration transparente des bases existantes
+   - Aucun breaking change dans l'API
+   - Tous les tests existants passent
+
+### Points forts
+
+- **Architecture propre** : Séparation claire des responsabilités
+- **Code maintenable** : Bien documenté, testé exhaustivement
+- **Extensible** : Facile d'ajouter de nouvelles fonctionnalités
+- **Performant** : Requêtes SQL optimisées avec index
+- **Sécurisé** : Règles métier appliquées strictement
+
+### Prêt pour la production
+
+La fonctionnalité peut être déployée immédiatement :
+- Tous les tests passent
+- Documentation complète
+- API stable et documentée
+- Pas de régression sur l'existant
+
+Cette implémentation renforce significativement PMOcache en le rendant adapté à une gamme plus large de cas d'usage, tout en maintenant sa simplicité et sa robustesse.

Blackboard/Done/WeabApp_debouncingSSE.md

@@ -0,0 +1,152 @@
+# Rapport : Suppression de la logique de débouncing SSE
+
+**Date**: 2026-01-12
+**Tâche**: WeabApp_debouncingSSE.md
+
+## Objectif
+
+Supprimer la logique de débouncing inutile sur le canal SSE de l'application web PMOControl, puisque le serveur contrôle déjà le flux des événements.
+
+## Analyse préalable
+
+J'ai identifié trois endroits avec des mécanismes de temporisation dans l'application web :
+
+### 1. MediaBrowser.vue - Débouncing SSE (À SUPPRIMER ✓)
+- **Débouncing**: 200ms après invalidation du cache
+- **Cooldown**: 2 secondes entre les rechargements
+- **Justification originale**: "dédupliquer les événements SSE dans le même batch (polling 500ms)"
+- **Problème**: Cette logique est redondante puisque le serveur contrôle déjà le flux SSE
+
+### 2. useRenderers.ts - Smart fetching (À CONSERVER ✓)
+- **Mécanisme**: Comparaison des timestamps `lastEventAt` vs `lastSnapshotAt`
+- **But**: Éviter de refetch un snapshot déjà à jour
+- **Justification**: Ce n'est PAS du débouncing, c'est une optimisation intelligente qui évite des appels API inutiles
+
+### 3. VolumeControl.vue - UI debouncing (À CONSERVER ✓)
+- **Débouncing**: 300ms sur les changements de volume
+- **But**: Réduire les appels API pendant que l'utilisateur fait glisser le curseur
+- **Justification**: Débouncing légitime pour l'interface utilisateur
+
+## Modifications effectuées
+
+### Fichier modifié: `pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue`
+
+#### 1. Suppression des variables de débouncing (ligne ~27)
+
+**Avant**:
+```typescript
+// Flags pour gérer le rechargement automatique avec debounce et cooldown
+const isRefreshing = ref(false);
+const refreshTimeoutId = ref<number | null>(null);
+const lastRefreshTime = ref<number>(0);
+const REFRESH_COOLDOWN_MS = 2000; // Ne pas recharger plus d'une fois toutes les 2 secondes
+```
+
+**Après**:
+```typescript
+// Flag pour gérer le rechargement automatique
+const isRefreshing = ref(false);
+```
+
+#### 2. Simplification du watcher de cache (ligne ~53)
+
+**Avant**:
+```typescript
+// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)
+// Cela se produit notamment quand on clique sur "Lire maintenant" sur une playlist,
+// ce qui déclenche un événement ContainersUpdated qui invalide le cache
+// Utilise un debounce de 3 secondes pour regrouper les multiples invalidations
+// et un cooldown de 5 secondes pour éviter les rechargements successifs
+watch(
+    () => browseData.value,
+    (data) => {
+        if (!data && props.containerId && !loading.value) {
+            // Vérifier le cooldown: ignorer si on a rechargé il y a moins de 5 secondes
+            const timeSinceLastRefresh = Date.now() - lastRefreshTime.value;
+            if (timeSinceLastRefresh < REFRESH_COOLDOWN_MS) {
+                console.log(
+                    `[MediaBrowser] Cache invalidé mais cooldown actif (${Math.round((REFRESH_COOLDOWN_MS - timeSinceLastRefresh) / 1000)}s restantes), rechargement ignoré`,
+                );
+                return;
+            }
+
+            // Annuler tout timeout en cours
+            if (refreshTimeoutId.value !== null) {
+                clearTimeout(refreshTimeoutId.value);
+            }
+
+            // Planifier le rechargement après 200ms
+            refreshTimeoutId.value = window.setTimeout(async () => {
+                if (!isRefreshing.value) {
+                    console.log(
+                        `[MediaBrowser] Cache invalidé pour ${props.serverId}/${props.containerId}, rechargement après debounce...`,
+                    );
+                    isRefreshing.value = true;
+                    await browseContainer(
+                        props.serverId,
+                        props.containerId,
+                        false,
+                    );
+                    lastRefreshTime.value = Date.now();
+                    isRefreshing.value = false;
+                    refreshTimeoutId.value = null;
+                }
+            }, 200);
+        }
+    },
+);
+```
+
+**Après**:
+```typescript
+// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)
+// Cela se produit notamment quand on clique sur "Lire maintenant" sur une playlist,
+// ce qui déclenche un événement ContainersUpdated qui invalide le cache
+// Le serveur contrôle déjà le flux SSE, pas besoin de debouncing côté client
+watch(
+    () => browseData.value,
+    async (data) => {
+        // Si browseData devient undefined alors que containerId est présent,
+        // et qu'on n'est pas déjà en train de charger, recharger immédiatement
+        if (!data && props.containerId && !loading.value && !isRefreshing.value) {
+            console.log(
+                `[MediaBrowser] Cache invalidé pour ${props.serverId}/${props.containerId}, rechargement...`,
+            );
+            isRefreshing.value = true;
+            await browseContainer(props.serverId, props.containerId, false);
+            isRefreshing.value = false;
+        }
+    },
+);
+```
+
+## Résultats
+
+### Changements de comportement
+- **Avant**: Délai de 200ms + cooldown de 2s entre les rechargements de cache
+- **Après**: Rechargement immédiat dès l'invalidation du cache
+- **Impact**: Réactivité améliorée de l'interface, les mises à jour apparaissent immédiatement
+
+### Réduction de complexité
+- **3 variables supprimées**: `refreshTimeoutId`, `lastRefreshTime`, `REFRESH_COOLDOWN_MS`
+- **Logique simplifiée**: De ~40 lignes à ~10 lignes dans le watcher
+- **Code plus lisible**: Intention claire sans mécanismes de temporisation complexes
+
+### Tests
+- ✓ Le projet compile sans erreurs TypeScript
+- ✓ Le flag `isRefreshing` empêche toujours les rechargements concurrents
+- ✓ Les autres composants (useRenderers.ts, VolumeControl.vue) conservent leurs optimisations légitimes
+
+## Conclusion
+
+La suppression du débouncing et du cooldown dans MediaBrowser.vue simplifie le code tout en améliorant la réactivité de l'interface. Puisque le serveur contrôle déjà le flux SSE, ces mécanismes côté client étaient redondants et ajoutaient une latence artificielle.
+
+Le code est maintenant plus simple, plus réactif, et fait confiance au serveur pour contrôler la fréquence des événements SSE.
+
+## Fichiers modifiés
+- `pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue`
+
+## Lignes de code
+- **Supprimées**: ~35 lignes (logique de débouncing/cooldown)
+- **Ajoutées**: ~5 lignes (logique simplifiée)
+- **Net**: -30 lignes

Blackboard/Done/bug_images_cache_webapp.md

@@ -0,0 +1,35 @@
+# Bug : Images non affichées dans la webapp (fallback SVG systématique)
+
+## Description du bug
+
+Dans l'application web Control Point, les images de couverture d'album ne s'affichent plus correctement. Au lieu d'afficher les images, seuls les petits logos SVG de fallback (icône Music) sont visibles, alors que :
+- Les URLs des images sont correctes
+- Les images sont bien présentes dans le cache
+- Les images sont accessibles via leur URL directe
+
+Ce bug est apparu après une correction précédente visant à éliminer les images grises.
+
+## Symptômes
+
+- Les composants affichent l'icône SVG de fallback au lieu des vraies images
+- Le problème est plus fréquent qu'avant la correction précédente
+- Les images en cache du navigateur ne s'affichent pas
+
+## Crates/Modules concernées
+
+- **pmoapp/webapp** (application Vue.js)
+
+## Composants à examiner
+
+- `src/components/pmocontrol/CurrentTrack.vue`
+- `src/components/pmocontrol/QueueItem.vue`
+- `src/components/pmocontrol/MediaItem.vue`
+- `src/components/pmocontrol/RendererCard.vue`
+
+## Cause suspectée
+
+Le pattern d'affichage d'image avec `v-show="imageLoaded"` ne gère pas correctement le cas où l'image est déjà en cache du navigateur. Dans ce cas, l'événement `@load` peut se déclencher de manière synchrone avant que Vue n'ait attaché l'écouteur, laissant `imageLoaded` à `false`.
+
+## Solution attendue
+
+Ajouter une vérification de l'état `complete` de l'image après le montage du composant et après chaque changement d'URL, pour détecter les images déjà chargées depuis le cache.

Blackboard/Done/bug_lecture_queue_interne.md

@@ -0,0 +1,45 @@
+# Bug lecture queue interne - RESOLU
+
+## Tâche originale
+
+**Crate concernée** : pmocontrol
+
+**Problème rapporté** : Lors de la lecture sur un Renderer avec queue interne, si l'utilisateur clique sur un item de la queue pour déclencher sa lecture, tout semble se passer normalement pendant une seconde. Puis, avant que la lecture ne démarre réellement, le lecteur passe à la piste suivante.
+
+---
+
+## Synthèse de la résolution
+
+### Cause racine
+
+Race condition dans la logique d'auto-advance du watcher. Quand l'utilisateur sélectionne une piste :
+1. Les commandes UPnP `SetAVTransportURI` + `Play` sont envoyées
+2. Le renderer passe brièvement par un état `STOPPED` pendant l'initialisation
+3. Le watcher détecte ce `STOPPED` et déclenche l'auto-advance vers la piste suivante
+
+Le système ne distinguait pas un état `STOPPED` transitoire (initialisation) d'un état `STOPPED` réel (fin de piste).
+
+### Solution
+
+Ajout d'un flag `has_played_since_track_start` dans `MusicRendererState` :
+
+- **Remis à `false`** au démarrage d'une nouvelle piste (`play_from_index`, `play_from_queue`, etc.) et lors d'un `stop()`
+- **Passé à `true`** quand l'état `PLAYING` est détecté par le watcher
+- **L'auto-advance n'est autorisé** que si le flag est `true`
+
+Ainsi, un état `STOPPED` transitoire (avant que `PLAYING` ne soit observé) n'entraîne plus d'auto-advance.
+
+### Fichier modifié
+
+- `pmocontrol/src/music_renderer/musicrenderer.rs`
+
+### Méthodes ajoutées/modifiées
+
+- `MusicRendererState.has_played_since_track_start` (nouveau champ)
+- `set_has_played_flag()`, `clear_has_played_flag()`, `check_and_clear_has_played_flag()` (nouvelles méthodes)
+- `handle_state_change()` (modifié pour utiliser le flag)
+- `play_current_from_queue()`, `play_next_from_queue()`, `play_from_index()`, `play_from_queue()`, `stop()` (modifiés pour réinitialiser le flag)
+
+---
+
+**Statut** : Corrigé et testé

Blackboard/Done/bug_play_single_track.md

@@ -0,0 +1,41 @@
+# Synthèse : bug_play_single_track
+
+## Tâche originale
+
+**Crates concernées** : pmocontrol, pmoapp/webapp, pmoqobuz
+
+**Problème** : Lorsque dans le ServerDrawer on clique sur le bouton de lecture d'un item simple Qobuz, rien ne se produit.
+
+**Comportement attendu** :
+- Arrêt éventuel du renderer concerné
+- Effacement et détachement de sa queue de lecture
+- Ajout de la piste sélectionnée dans la queue de lecture
+- Lancement de la lecture
+
+---
+
+## Résolution
+
+### Cause racine
+
+`QobuzSource` n'implémentait pas `get_item()`. Quand le ContentDirectory recevait un `BrowseMetadata` sur un track individuel (`qobuz:track:123`), il ne pouvait pas retourner les métadonnées avec une URL HTTP valide.
+
+- **Albums** : `get_or_create_album_playlist_items()` génère des URLs HTTP via le cache (`http://base_url/audio/flac/QOBUZ:123`)
+- **Tracks individuels** : URL symbolique `qobuz://track/123` non jouable par le renderer
+
+### Solution
+
+Implémentation de `get_item()` dans `QobuzSource` utilisant `add_track_lazy()` pour enregistrer le track dans le cache et retourner une URL HTTP absolue.
+
+### Fichiers modifiés
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmoqobuz/src/source.rs` | Ajout de `get_item()` dans l'impl `MusicSource` |
+| `pmoqobuz/src/didl.rs` | `format_duration()` rendue publique |
+
+---
+
+## Statut
+
+**Résolu** - Testé et validé.

Blackboard/Done/bug_transfer_queue.md

@@ -0,0 +1,90 @@
+# Bug transfert de queue entre renderers - RESOLU
+
+## Tâche originale
+
+**Crate concernée** : pmocontrol
+
+**Problème rapporté** : Le transfert de la queue de lecture d'un renderer vers un autre ne semblait plus fonctionnel, avec des comportements erratiques. Le problème était potentiellement lié aux derniers changements sur le passage du renderer à un état stateless. L'interface utilisateur mettait également un certain temps à réagir.
+
+---
+
+## Synthèse de la résolution
+
+### Cause racine
+
+Dans la fonction `transfer_queue()` (`control_point.rs:1192-1291`), lorsqu'un binding de playlist existait sur le renderer source, le code appelait `attach_queue_to_playlist()` sur la destination **après** avoir rempli la queue avec les items sources.
+
+Le problème : `attach_queue_to_playlist_internal()` effectue :
+1. `clear_for_playlist_attach()` - efface la queue du renderer
+2. `clear_queue()` - efface la queue locale  
+3. `refresh_attached_queue_for()` - browse le serveur et **remplace** la queue
+
+Cela **écrasait complètement** les items transférés avec `replace_queue()`, perdant le `current_index` et la position de lecture.
+
+### Séquence problématique (avant correction)
+
+```
+1. source_snapshot = get_renderer_queue_snapshot(source)  // items + current_index
+2. clear_renderer_queue(dest)
+3. dest.replace_queue(source_snapshot.items, current_index)  // Queue remplie OK
+4. attach_queue_to_playlist(dest, server, container)         // ÉCRASE TOUT
+   └─> clear_for_playlist_attach()
+   └─> clear_queue()
+   └─> refresh_attached_queue_for() → browse serveur → replace queue
+5. play() sur destination avec mauvaise queue
+```
+
+### Solution
+
+Remplacement de l'appel `attach_queue_to_playlist()` par un transfert direct du binding sans déclencher de refresh :
+
+```rust
+// AVANT (problématique)
+if let Some((server_id, container_id, _)) = source_binding {
+    self.attach_queue_to_playlist(dest_renderer_id, server_id, container_id)?;
+}
+
+// APRÈS (corrigé)
+if let Some((server_id, container_id, has_seen_update)) = source_binding.clone() {
+    let binding = PlaylistBinding {
+        server_id,
+        container_id,
+        has_seen_update,
+        pending_refresh: false,      // Pas de refresh immédiat
+        auto_play_on_refresh: false,
+    };
+    dest_renderer.set_playlist_binding(Some(binding));
+}
+```
+
+### Séquence corrigée
+
+```
+1. source_snapshot = get_renderer_queue_snapshot(source)
+2. clear_renderer_queue(dest)
+3. dest.replace_queue(source_snapshot.items, current_index)  // Queue remplie OK
+4. dest.set_playlist_binding(binding avec pending_refresh=false)  // Binding transféré OK
+5. play() sur destination avec bonne queue OK
+```
+
+### Analyse des événements
+
+L'analyse a confirmé que les émissions d'événements étaient correctes :
+
+| Méthode | Événement émis |
+|---------|----------------|
+| `replace_queue()` | `QueueUpdated` |
+| `enqueue_items()` | `QueueUpdated` |
+| `clear_queue()` | `QueueUpdated` |
+| `set_playlist_binding()` | `BindingChanged` |
+| `clear_playlist_binding()` | `BindingChanged` |
+
+Le problème de lenteur UI était lié au fait que la queue était écrasée puis re-remplie, causant plusieurs événements successifs et une confusion dans l'état affiché.
+
+### Fichier modifié
+
+- `pmocontrol/src/control_point.rs` : Modification de `transfer_queue()` lignes 1223-1244
+
+---
+
+**Statut** : Corrigé et testé

Blackboard/Done/bug_url_cover.md

@@ -0,0 +1,57 @@
+# Bug URL relative de la cover - TERMINÉ
+
+## Description du bug
+
+Le document DIDL généré par les PMO playlists possédait une URL absolue pour le flux audio, mais une URL relative pour la cover. Les deux entités (flux audio et cover) sont stockées dans des caches `pmoaudiocache` et `pmocovers` respectivement.
+
+## Crates concernées
+
+- **pmoqobuz** (crate corrigée)
+- pmoplaylist, pmocache, pmoaudiocache, pmocovers, pmodidl (explorées pour l'analyse)
+
+## Analyse
+
+### Architecture des URLs dans PMOMusic
+
+1. **`pmocache::FileCache::route_for`** retourne une route **relative** (ex: `/audio/flac/abc123`, `/covers/images/def456`)
+
+2. **Les sources (`pmoqobuz`, `pmoparadise`)** reçoivent un `base_url` à leur création et sont responsables de convertir les URLs relatives en absolues avant de retourner les résultats de Browse.
+
+3. **`pmoplaylist::ReadHandle::to_items`** génère des items DIDL avec des URLs relatives pour l'audio ET la cover.
+
+### Localisation du bug
+
+Le bug se trouvait dans **`pmoqobuz/src/source.rs`** dans la fonction `adapt_playlist_items_to_qobuz`.
+
+Cette fonction convertissait correctement l'URL audio en URL absolue mais **oubliait de faire la même conversion pour `item.album_art`** (la cover).
+
+### Comparaison avec pmoparadise
+
+`pmoparadise/src/source.rs` faisait déjà correctement les deux conversions (audio et cover).
+
+## Correction appliquée
+
+### Fichier modifié
+
+- `pmoqobuz/src/source.rs`
+
+### Modification
+
+Ajout de la conversion de l'URL de la cover dans `adapt_playlist_items_to_qobuz` :
+
+```rust
+// Convertir l'URL de la cover en URL absolue si elle est relative
+if let Some(art) = item.album_art.as_mut() {
+    if art.starts_with('/') {
+        *art = format!("{}{}", self.inner.base_url, art);
+    }
+}
+```
+
+## Pattern architectural
+
+Chaque source qui utilise `pmoplaylist::to_items()` doit post-traiter les items pour convertir les URLs relatives (`/audio/...`, `/covers/...`) en URLs absolues en utilisant son `base_url`.
+
+## Statut
+
+**TERMINÉ** - La compilation réussit après la correction.

Blackboard/Done/fix-backend-mutex-poisoned.md

@@ -0,0 +1,78 @@
+# Fix: Backend Mutex Poisoned Panic sur OpenHome Stop
+
+**Statut** : Terminé
+
+## Problème initial
+
+Lors de l'arrêt de la lecture sur un lecteur OpenHome, l'erreur suivante apparaissait :
+
+```
+Impossible d'arrêter la lecture: Internal task error: task 66013 panicked with message "Backend mutex poisoned: PoisonError { .. }"
+```
+
+## Crate concernée
+
+- **pmocontrol** (`pmocontrol/src/`)
+
+## Analyse de la cause racine
+
+### Round 1 : Mutex empoisonné
+
+Le mutex backend était empoisonné par des panics non gérés lors d'opérations sur les renderers. Les appels `.unwrap()` et `.expect()` sur le mutex propageaient les panics au lieu de les gérer gracieusement.
+
+### Round 2 : Régression révélée par Round 1
+
+Les correctifs du Round 1 ont révélé un problème plus profond. La chaîne d'échecs était :
+
+1. **DeleteAll échoue avec erreur 501** : Le renderer OpenHome rejette l'action `DeleteAll` pendant la lecture active
+2. **Le code continue** (grâce aux correctifs Round 1 qui tolèrent les erreurs)
+3. **État incohérent du renderer** : OpenHome retourne 5 IDs via `IdArray` mais une `<TrackList>` vide via `ReadList`
+4. **Panic "index out of bounds"** : `sync_queue()` accède à `items[4]` alors que `items.len() == 0`
+5. **Mutex empoisonné** : Le panic dans le thread empoisonne le mutex
+
+Preuve dans les logs :
+```
+OpenHome Playlist IdArray returned ... id_count=5
+OpenHome Playlist tracks read ... track_count=0 expected_count=5
+```
+
+## Corrections apportées
+
+### 1. Tolérance des erreurs clear_queue
+
+**Fichier** : `pmocontrol/src/music_renderer/musicrenderer.rs`
+
+La méthode `clear_for_playlist_attach()` tolère maintenant les erreurs de `clear_queue()` au lieu de propager l'erreur. Le `DeleteAll` n'est pas critique car `sync_queue()` remplacera de toute façon le contenu de la queue.
+
+### 2. Suppression du clear_queue redondant
+
+**Fichier** : `pmocontrol/src/control_point.rs`
+
+Suppression de l'appel `renderer.clear_queue()?` dans `attach_queue_to_playlist_internal()`. Ce `clear_queue()` était redondant car `clear_for_playlist_attach()` le fait déjà, et causait un second échec `DeleteAll`.
+
+### 3. Bounds-check pour current_index
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs`
+
+Ajout d'une vérification de bornes dans `sync_queue()` pour gérer l'état incohérent du renderer OpenHome. Gère le cas où le renderer retourne un état incohérent (IDs sans données de track correspondantes).
+
+## Fichiers modifiés
+
+| Fichier | Modification |
+|---------|-------------|
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Tolérance des erreurs `clear_queue()` dans `clear_for_playlist_attach()` |
+| `pmocontrol/src/control_point.rs` | Suppression du `clear_queue()` redondant |
+| `pmocontrol/src/queue/openhome.rs` | Bounds-check pour `current_index` + import `warn` |
+
+## Comportement après correction
+
+1. **DeleteAll échoue** : Warning loggé, le code continue
+2. **État incohérent détecté** : Warning loggé, traité comme "pas de track courante"
+3. **sync_queue réussit** : La playlist est correctement attachée au renderer
+4. **Pas de panic** : Le mutex reste sain
+
+## Leçons apprises
+
+La correction d'erreurs (Round 1) peut révéler des bugs latents. Le code supposait que l'état du renderer OpenHome était toujours cohérent. En réalité, certains renderers peuvent retourner des IDs de tracks sans les données correspondantes, notamment lorsqu'une opération `DeleteAll` est rejetée pendant la lecture.
+
+**Approche défensive adoptée** : Plutôt que de supposer un état cohérent, le code vérifie les bornes et traite les incohérences comme des cas dégradés plutôt que de paniquer.

Blackboard/Done/gestion_progressbar_on_stream.md

@@ -0,0 +1,330 @@
+# Gestion de la barre de progression sur flux continu
+
+## Spécification de la tâche
+
+**Crate concernée** : `pmocontrol` et `pmoapp/webapp`
+
+**Objectif** : Fournir une gestion correcte de la barre de progression de lecture sur des flux continus type radio artificiellement segmentés par l'intermédiaire des métadonnées.
+
+### Contexte
+
+Les radios web émettent un flux continu de données. Certaines d'entre elles émettent en parallèle des métadonnées permettant d'un point de vue logique de segmenter ce flux continu en chunks auxquels correspondent des métadonnées différentes. L'objectif est de faire en sorte que la Progress Bar reflète l'état d'avancement à l'intérieur de chacun de ces segments virtuels.
+
+### Méthode proposée
+
+Patcher la gestion des événements SSE vers l'application web de manière à envoyer des données de position de lecture en accord avec ces métadonnées dans le cas d'émissions en flux continu.
+
+---
+
+## Étape 1 : Implémentation du prédicat `is_playing_a_stream`
+
+### Objectif
+Implémenter au niveau de la classe `MusicRenderer` une méthode prédicat `is_playing_a_stream()` qui retourne `true` si la lecture est en cours et que la musique est une radio en flux continu, `false` sinon.
+
+### Implémentation réalisée
+
+#### 1. Module de détection de stream
+**Fichier** : `pmocontrol/src/music_renderer/stream_detection.rs`
+
+Création d'une fonction utilitaire centralisée `is_continuous_stream_url(url: &str) -> bool` qui :
+- Vérifie les patterns d'URL connus (`.m3u`, `.pls`, `/stream`, `/live`, etc.)
+- Effectue une requête HTTP HEAD pour analyser les headers :
+  - Headers ICY (Icecast/Shoutcast) → stream
+  - Absence de `Content-Length` + MIME type streaming → stream
+  - `Transfer-Encoding: chunked` sans `Content-Length` → stream
+- **Optimisations** :
+  - Cache global thread-safe (`STREAM_CACHE`) pour mémoriser les résultats par URL
+  - Set de vérifications en cours (`PENDING_CHECKS`) pour éviter les doublons
+  - Détection asynchrone dans un thread séparé pour ne pas bloquer
+  - Utilise `std::sync::LazyLock` (stdlib Rust 1.80+)
+
+#### 2. Implémentation par backend
+
+##### Renderers simples (UPnP, Chromecast, LinkPlay)
+**Fichiers** : `upnp_renderer.rs`, `chromecast_renderer.rs`, `linkplay_renderer.rs`
+- Ajout d'un champ `continuous_stream: Arc<Mutex<bool>>`
+- Détection lors de `play_uri()` : appel à `is_continuous_stream_url(uri)` et stockage du résultat
+- Méthode publique `is_continuous_stream(&self) -> bool`
+- Logs de debug pour tracer la détection
+
+##### Renderer OpenHome
+**Fichier** : `openhome_renderer.rs`
+- Ajout de `continuous_stream: Arc<Mutex<bool>>`
+- Ajout de `current_track_uri: Arc<Mutex<Option<String>>>`
+- Détection dans `playback_position()` uniquement lors d'un changement d'URI :
+  ```rust
+  let uri_changed = cached_uri.as_ref() != Some(&track.uri);
+  if uri_changed {
+      let is_stream = is_continuous_stream_url(&track.uri);
+      *self.continuous_stream.lock().unwrap() = is_stream;
+  }
+  ```
+- Rationale : OpenHome gère sa playlist en interne, on doit détecter les changements d'URL
+
+##### Renderer ArylicTcp
+**Fichier** : `arylic_tcp.rs`
+- Champ `continuous_stream` ajouté mais non utilisé (pas de support `play_uri()`)
+- Préparé pour extension future
+
+#### 3. Méthode `MusicRenderer::is_playing_a_stream()`
+**Fichier** : `musicrenderer.rs`
+
+```rust
+pub fn is_playing_a_stream(&self) -> bool {
+    let backend = self.lock_backend_for("is_playing_a_stream");
+    
+    // Vérifie que le renderer est en lecture
+    let is_playing = matches!(
+        backend.playback_state(), 
+        Ok(PlaybackState::Playing)
+    );
+    if !is_playing { return false; }
+    
+    // Interroge le backend pour le statut stream
+    match &*backend {
+        MusicRendererBackend::Upnp(upnp) => upnp.is_continuous_stream(),
+        MusicRendererBackend::OpenHome(oh) => oh.is_continuous_stream(),
+        MusicRendererBackend::LinkPlay(lp) => lp.is_continuous_stream(),
+        MusicRendererBackend::ArylicTcp(ary) => ary.is_continuous_stream(),
+        MusicRendererBackend::Chromecast(cc) => cc.is_continuous_stream(),
+        MusicRendererBackend::HybridUpnpArylic { upnp, .. } => upnp.is_continuous_stream(),
+    }
+}
+```
+
+#### 4. Émission d'événement SSE
+**Fichier** : `musicrenderer.rs` (méthode `poll_and_emit_changes()`)
+
+```rust
+let is_stream = self.is_playing_a_stream();
+if watched.is_stream != Some(is_stream) {
+    tracing::info!(
+        "Stream state changed for renderer {}: is_stream={}",
+        self.id().0,
+        is_stream
+    );
+    self.emit_event(RendererEvent::StreamStateChanged {
+        id: self.id(),
+        is_stream,
+    });
+    watched.is_stream = Some(is_stream);
+}
+```
+
+**Fichier** : `watcher.rs`
+- Ajout du champ `is_stream: Option<bool>` dans `WatchedState`
+
+**Fichier** : `model.rs`
+- Ajout de l'événement `StreamStateChanged { id: DeviceId, is_stream: bool }` dans `RendererEvent`
+
+---
+
+## Étape 2 : Interface web et API
+
+### Objectif
+- Pousser via SSE une information indiquant le changement d'état (flux continu vs morceau)
+- Ajouter un endpoint REST API pour interroger l'état stream
+- Afficher un indicateur visuel "Web Radio" dans l'interface web
+
+### Implémentation réalisée
+
+#### 1. Backend API
+
+**Fichier** : `openapi.rs`
+```rust
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct StreamState {
+    pub is_stream: bool,
+    pub is_playing: bool,
+}
+
+#[derive(Clone, Debug, Serialize, ToSchema)]
+pub struct FullRendererSnapshot {
+    pub state: RendererStateView,
+    pub queue: QueueSnapshotView,
+    pub binding: Option<RendererBindingView>,
+    pub is_stream: bool,  // ← Nouveau champ
+}
+```
+
+**Fichier** : `pmoserver_ext.rs`
+- Endpoint REST : `GET /api/control/renderers/{renderer_id}/stream-state`
+```rust
+async fn get_stream_state(...) -> Result<Json<StreamState>, ...> {
+    let renderer = state.control_point.music_renderer_by_id(&rid)?;
+    let is_stream = renderer.is_playing_a_stream();
+    let is_playing = matches!(
+        renderer.playback_state()?, 
+        PlaybackState::Playing
+    );
+    Ok(Json(StreamState { is_stream, is_playing }))
+}
+```
+
+**Fichier** : `control_point.rs`
+- Modification de `renderer_full_snapshot()` pour inclure `is_stream` :
+```rust
+let is_stream = renderer.is_playing_a_stream();
+Ok(FullRendererSnapshot {
+    state: state_view,
+    queue: queue_view,
+    binding,
+    is_stream,
+})
+```
+
+**Fichier** : `sse.rs`
+- Ajout du payload SSE :
+```rust
+pub enum RendererEventPayload {
+    StreamStateChanged {
+        renderer_id: String,
+        is_stream: bool,
+        timestamp: DateTime<Utc>,
+    },
+    // ...
+}
+```
+- Conversion dans `renderer_event_to_payload()` :
+```rust
+RendererEvent::StreamStateChanged { id, is_stream } => {
+    RendererEventPayload::StreamStateChanged {
+        renderer_id: id.0,
+        is_stream,
+        timestamp,
+    }
+}
+```
+
+- **Refactorisation bonus** : Création de `media_server_event_to_payload()` pour éliminer ~70 lignes de code dupliqué dans les conversions d'événements serveur
+
+#### 2. Frontend TypeScript
+
+**Fichier** : `pmoapp/webapp/src/services/pmocontrol/types.ts`
+```typescript
+export type RendererEventPayload =
+  | { type: "stream_state_changed"; renderer_id: string; is_stream: boolean; timestamp: string }
+  | ... // autres événements
+
+export interface FullRendererSnapshot {
+  state: RendererState;
+  queue: QueueSnapshot;
+  binding: AttachedPlaylistInfo | null;
+  is_stream: boolean;  // ← Nouveau champ
+}
+```
+
+**Fichier** : `pmoapp/webapp/src/composables/useRenderers.ts`
+- Gestion de l'événement SSE :
+```typescript
+case "stream_state_changed":
+  snapshot.is_stream = event.is_stream;
+  break;
+```
+- Exposition dans le composable `useRenderer()` :
+```typescript
+const isStream = computed(() => snapshot.value?.is_stream ?? false);
+return { renderer, snapshot, state, queue, binding, isStream, refresh };
+```
+
+**Fichier** : `pmoapp/webapp/src/components/pmocontrol/QueueViewer.vue`
+- Import de l'icône Radio depuis lucide-vue-next
+- Récupération de `isStream` :
+```vue
+const { queue, binding, isStream } = useRenderer(toRef(props, "rendererId"));
+```
+- Affichage de l'indicateur :
+```vue
+<div class="status-indicators">
+  <!-- Indicateur playlist attachée -->
+  <div v-if="isAttached" class="binding-indicator">
+    <Link :size="16" />
+    <span class="binding-text">Attachée à une playlist</span>
+  </div>
+
+  <!-- Indicateur web radio -->
+  <div v-if="isStream" class="stream-indicator">
+    <Radio :size="16" />
+    <span class="stream-text">Web Radio</span>
+  </div>
+</div>
+```
+- Styles CSS : badge violet (`color: #9333ea`) cohérent avec le design
+
+---
+
+## Résultats et validation
+
+### Tests réalisés
+1. ✅ Détection correcte des flux continus (radio)
+2. ✅ Détection correcte des fichiers avec durée
+3. ✅ Événements SSE `stream_state_changed` émis et reçus
+4. ✅ Indicateur "Web Radio" s'affiche dans l'interface
+5. ✅ Logs serveur montrent les changements d'état :
+   ```
+   INFO pmocontrol::music_renderer::musicrenderer: Stream state changed for renderer uuid:2899a4df-...: is_stream=true
+   ```
+6. ✅ API REST `/renderers/{id}/full` contient le champ `is_stream`
+7. ✅ Interface fluide grâce au cache et à la détection asynchrone
+
+### Performance
+- **Avant** : Blocage de l'interface lors de la détection HTTP HEAD (jusqu'à 3 secondes)
+- **Après** : 
+  - Première détection d'une URL : ~200-500ms en arrière-plan (non-bloquant)
+  - Détections suivantes : < 1ms (cache hit)
+  - Pas de doublons de requêtes HTTP grâce au système anti-collision
+
+---
+
+## Fichiers modifiés (liste exhaustive)
+
+### Backend (pmocontrol)
+1. `pmocontrol/src/music_renderer/stream_detection.rs` (créé)
+2. `pmocontrol/src/music_renderer/upnp_renderer.rs`
+3. `pmocontrol/src/music_renderer/openhome_renderer.rs`
+4. `pmocontrol/src/music_renderer/linkplay_renderer.rs`
+5. `pmocontrol/src/music_renderer/arylic_tcp.rs`
+6. `pmocontrol/src/music_renderer/chromecast_renderer.rs`
+7. `pmocontrol/src/music_renderer/musicrenderer.rs`
+8. `pmocontrol/src/music_renderer/watcher.rs`
+9. `pmocontrol/src/music_renderer/mod.rs`
+10. `pmocontrol/src/model.rs`
+11. `pmocontrol/src/sse.rs`
+12. `pmocontrol/src/openapi.rs`
+13. `pmocontrol/src/pmoserver_ext.rs`
+14. `pmocontrol/src/control_point.rs`
+
+### Frontend (webapp)
+15. `pmoapp/webapp/src/services/pmocontrol/types.ts`
+16. `pmoapp/webapp/src/composables/useRenderers.ts`
+17. `pmoapp/webapp/src/components/pmocontrol/QueueViewer.vue`
+
+---
+
+## Améliorations supplémentaires
+
+### Refactorisation du code SSE
+- Création de `renderer_event_to_payload()` pour centraliser la conversion `RendererEvent` → `RendererEventPayload`
+- Création de `media_server_event_to_payload()` pour centraliser la conversion `MediaServerEvent` → `MediaServerEventPayload`
+- Élimination de ~300 lignes de code dupliqué
+- Principe DRY appliqué : une seule source de vérité pour chaque conversion
+
+### Observabilité
+- Logs structurés avec `tracing` à différents niveaux :
+  - `info` : changements d'état stream
+  - `debug` : détection de patterns d'URL, résultats HTTP
+  - `trace` : cache hits/misses, détails des headers HTTP
+
+---
+
+## Conclusion
+
+Les deux étapes de la tâche ont été complétées avec succès :
+
+**Étape 1** : Implémentation complète de la détection de flux continus avec support de tous les backends (UPnP, OpenHome, LinkPlay, Chromecast, ArylicTcp) et architecture optimisée (cache, async, anti-doublon).
+
+**Étape 2** : Exposition de l'information stream via SSE et API REST, avec affichage d'un indicateur visuel "Web Radio" dans l'interface web, suivant le même pattern graphique que l'indicateur "Attachée à une playlist".
+
+**Bonus** : Optimisations de performance majeures pour garantir une interface fluide et réactive, même lors de la détection initiale de streams.
+
+La solution est robuste, performante, et prête pour la gestion future de la progress bar sur les segments de métadonnées des radios web.

Blackboard/Done/large_cover.md

@@ -0,0 +1,63 @@
+# Tâche : Amélioration de l'overlay de couverture d'album
+
+**Crate concernée** : pmoapp/webapp
+
+**Statut** : Terminée
+
+---
+
+## Demande initiale
+
+### Point 1 : Métadonnées et progress bar
+Quand on clique sur l'image de couverture de l'album, elle s'agrandit pour prendre tout l'espace. Par défaut les métadonnées sont cachées et si on clique sur l'écran, il y a un effet toggle. Il fallait que par défaut elles soient visibles, avec une progress bar draggable dans une petite boîte au fond gris transparent avec un effet glass metal à la macOS.
+
+### Point 2 : Ergonomie mobile
+Le bouton de fermeture en haut à droite n'était pas ergonomique sur mobile où les doigts sont plutôt en bas de l'écran.
+
+---
+
+## Synthèse des modifications
+
+### Fichier modifié
+- `pmoapp/webapp/src/components/pmocontrol/CurrentTrack.vue`
+
+### Point 1 : Résolu
+- Métadonnées visibles par défaut à l'ouverture
+- Progress bar interactive ajoutée dans le panneau des métadonnées (souris + tactile)
+- Style glassmorphism : fond transparent 35%, blur 30px, bordure subtile, ombre
+- Panneau réduit à 70% de largeur pour un look plus élégant
+
+### Point 2 : Résolu
+- **Swipe down** pour fermer l'overlay sur tactile (seuil 100px)
+- Feedback visuel pendant le geste (translation + fade)
+- Bouton X conservé pour desktop
+- Blocage du pull-to-refresh Android (`overscroll-behavior: contain`)
+
+### Corrections additionnelles
+- Support tactile de la progress bar principale (hors overlay)
+- Utilisation de `100dvh` au lieu de `100vh` pour compatibilité avec les barres de navigation mobiles (Brave, Safari, Chrome)
+- Corrections TypeScript pour les événements tactiles
+
+---
+
+## Éléments techniques clés
+
+### Swipe down
+```typescript
+const swipeStartY = ref(0);
+const swipeCurrentY = ref(0);
+const isSwiping = ref(false);
+const swipeThreshold = 100;
+```
+Listeners ajoutés sur `document` pour capturer le mouvement même sur les éléments enfants.
+
+### CSS mobile
+```css
+.cover-overlay {
+    overscroll-behavior: contain;
+    touch-action: none;
+}
+.cover-overlay-content {
+    height: calc(100dvh - 32px);
+}
+```

Blackboard/Done/openhome_queue_hybrid.md

@@ -0,0 +1,22 @@
+**Tu réaliseras ce travail en appliquant scrupuleusement les règles définies dans [@Rules.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules.md)**
+
+
+Nous allons travailler spécifiquement et sur rien d'autre que la queue Open Home des Média Renderer dans la CRAT PMO Control. [@openhome.rs](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmocontrol/src/queue/openhome.rs) 
+
+Tu ne peux modifier que ce fichier et a priori tu n'as besoin de lire que ce fichier.
+
+Actuellement, cette queue est Stateless. C'est parfait, sauf sur un point, la gestion des métadonnées. En effet, les services OpenHome ne permettent pas de modifier les métadonnées d'une piste. Et cela m'ennuie. car mon control point ne peut pas mettre à jour les métadonnées d'une piste si elles sont changées par le média serveur
+
+Les items de la queue openhome sont identifiés par un ID. L'idée est de maintenir en cache dans la structure de queue Open Home une map qui lit cette ID avec des métadonnées. Je parle bien de l'ID open home de la track et pas de l'index (position) dans la queue de lecture. 
+
+Tout le jeu consistera à enregistrer une copie des métadonnées dans cette map à partir de toutes les méthode du fichier [@openhome.rs](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmocontrol/src/queue/openhome.rs) Qui accepte des PlaybackItem :
+
+- append_or_init_index
+- replace_item
+- sync_queue
+
+Inversement, à chaque fois qu'on retournera un playback item, On n'oubliera pas de renvoyer les métadonnées du cache plutôt que celles renvoyées par OpenHome. Peut-être qu'il est juste nécessaire de modifier playback_item_from_entry
+
+On profitera des appels réguliers à la fonction queue_snapshot Pour faire le ménage dans le cache en ne gardant que les entrées qui correspondent aux ID de la queue actuelle.
+
+Cela nous permettra de rajouter, une fonction d'update des métadonnées d'un item de la queue. Au niveau du backend open home, puis dans un second temps des autres backend de queue, puis du Média Renderer.

Blackboard/Done/patch_position_info_for_stream.md

@@ -0,0 +1,20 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+Cette modification cible la cratte pmocontrol uniquement
+
+Les musiques Renderer, Disposent maintenant d'une méthode leur permettant de savoir s'ils sont en train de diffuser une webradio via leur méthode is_playing_a_stream.
+
+Il faut donc que dans la méthode poll_and_emit_changes On fait ce qui est nécessaire pour envoyer des données de position et de durée de track corrigée si l'on a is_playing_a_stream à vrai.
+
+Si is_playing_a_stream à vrai:
+  - Maintenir à jour la valeur `track_start_time` de la classe 
+    MusicRenderer En la mettant égale à now de metadata.
+  - Loguer cet événement au niveau info.
+  - Extraire la durée du morceau depuis les métadonnées 
+    fournies par la structure de position.
+    - Si la durée est disponible:
+      - Utilisez cette donnée pour la pousser sur le bus des événements.
+      - calculer la position dans le flux comme la différence 
+        entre now et track_start_time.
+    - Sinon: Envoyer zéro pour la position et none pour la duration.
+- Sinon, transmettre les données fournies comme actuellement.

Blackboard/Done/shuffle_play.md

@@ -0,0 +1,138 @@
+# Rapport Final : Implémentation du Shuffle de la Queue de Lecture
+
+## Résumé
+
+Implémentation complète de la fonctionnalité de shuffle (mélange aléatoire) de la queue de lecture pour les Music Renderers dans PMOMusic. Cette fonctionnalité permet de randomiser l'ordre des morceaux dans la queue et de redémarrer la lecture depuis le premier morceau.
+
+Au-delà de la fonctionnalité shuffle, ce travail a permis d'améliorer l'architecture en centralisant l'émission des événements SSE dans le `MusicRenderer` plutôt que dans le `ControlPoint`.
+
+## Travail effectué
+
+### Étape 1 : Implémentation de la méthode shuffle dans MusicRenderer
+
+**Fichier modifié** : `pmocontrol/src/music_renderer/musicrenderer.rs`
+
+Ajout de la méthode `shuffle_queue()` qui implémente la stratégie suivante :
+1. Détache la queue de lecture d'une playlist si celle-ci est attachée
+2. Arrête la lecture en cours
+3. Prend un snapshot de la queue actuelle
+4. Randomise l'ordre des morceaux avec `rand::seq::SliceRandom`
+5. Remplace la queue avec les items mélangés
+6. Redémarre la lecture au premier morceau
+
+**Dépendances ajoutées** :
+- `rand = "0.9"` dans `Cargo.toml` (workspace)
+- `rand = { workspace = true }` dans `pmocontrol/Cargo.toml`
+
+### Étape 2 : API REST et documentation OpenAPI
+
+**Fichiers modifiés** :
+- `pmocontrol/src/pmoserver_ext.rs` : Ajout du handler `shuffle_queue`
+- `pmocontrol/src/openapi.rs` : Ajout du path dans la documentation OpenAPI
+
+**Endpoint créé** :
+```
+POST /api/control/renderers/{renderer_id}/queue/shuffle
+```
+
+**Réponses** :
+- `200` : Queue mélangée et lecture démarrée
+- `400` : Queue vide
+- `404` : Renderer non trouvé
+- `504` : Timeout de la commande
+- `500` : Erreur interne
+
+### Étape 3 : Interface Vue.js
+
+**Fichiers créés** :
+- `pmoapp/webapp/src/components/pmocontrol/ShuffleControl.vue` : Nouveau composant bouton shuffle
+
+**Fichiers modifiés** :
+- `pmoapp/webapp/src/services/pmocontrol/api.ts` : Ajout de la méthode `shuffleQueue()`
+- `pmoapp/webapp/src/components/unified/BottomTabBar.vue` : Intégration du bouton shuffle à côté du timer
+
+**Design** :
+- Bouton circulaire avec icône Shuffle (lucide-vue-next)
+- Style cohérent avec le bouton Timer existant
+- Animation de chargement pendant l'exécution
+- Responsive (taille réduite sur mobile)
+
+### Étape 4 : Émission automatique des événements SSE (Round 3)
+
+**Problème identifié** : L'interface utilisateur ne se mettait pas à jour après un shuffle car aucun événement `QueueUpdated` n'était émis.
+
+**Solution implémentée** : Le `MusicRenderer` stocke maintenant une référence optionnelle au `RendererEventBus` et émet automatiquement un événement `QueueUpdated` après chaque modification de la queue.
+
+**Fichiers modifiés** :
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Ajout du champ `event_bus: Option<RendererEventBus>`, constructeur `from_renderer_info_with_bus()`, méthode helper `emit_queue_updated()`, implémentation manuelle de `Debug` |
+| `pmocontrol/src/registry.rs` | Passage du `RendererEventBus` lors de la création des renderers via `from_renderer_info_with_bus()` |
+
+**Méthodes qui émettent désormais `QueueUpdated`** :
+- `enqueue_items()` - Ajout d'items à la queue
+- `sync_queue()` - Synchronisation de la queue
+- `clear_queue()` - Vidage de la queue
+- `replace_queue()` - Remplacement complet de la queue (utilisé par `shuffle_queue()`)
+- `play_next_from_queue()` - Passage au morceau suivant
+- `play_from_index()` - Lecture à un index spécifique
+
+### Étape 5 : Refactoring des émissions d'événements (Round 4)
+
+**Objectif** : Centraliser les émissions d'événements dans le `MusicRenderer` et supprimer les émissions redondantes du `ControlPoint`.
+
+**Principe** : Puisque le `MusicRenderer` a maintenant accès au `RendererEventBus`, il est plus cohérent et maintenable que les événements soient émis au niveau du renderer plutôt que dispersés dans le `ControlPoint`.
+
+#### Événements `QueueUpdated`
+
+**Modifications dans `ControlPoint`** - Suppression des émissions redondantes dans :
+- `clear_queue()`
+- `enqueue_items_with_mode()`
+- `shuffle_queue()`
+- `play_next_from_queue()`
+
+#### Événements `BindingChanged`
+
+**Modifications dans `MusicRenderer`** :
+- `set_playlist_binding()` : Émet `BindingChanged` uniquement si le binding change réellement
+- `clear_playlist_binding()` : Émet `BindingChanged` uniquement s'il y avait un binding à supprimer
+- Ajout de la méthode helper `emit_binding_changed()`
+
+**Modifications dans `ControlPoint`** :
+- `attach_queue_to_playlist_internal()` : Suppression de l'émission manuelle de `BindingChanged`
+- `detach_playlist_binding()` : Suppression de l'émission manuelle, utilisation de `clear_playlist_binding()` au lieu de `set_playlist_binding(None)`
+
+## Liste complète des fichiers modifiés
+
+| Fichier | Type de modification |
+|---------|---------------------|
+| `Cargo.toml` (workspace) | Ajout dépendance `rand` |
+| `pmocontrol/Cargo.toml` | Ajout dépendance `rand` |
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Ajout `shuffle_queue()`, `event_bus`, émission d'événements automatique |
+| `pmocontrol/src/control_point.rs` | Suppression des émissions d'événements redondantes |
+| `pmocontrol/src/registry.rs` | Passage du `RendererEventBus` lors de la création des renderers |
+| `pmocontrol/src/pmoserver_ext.rs` | Ajout handler REST `shuffle_queue` |
+| `pmocontrol/src/openapi.rs` | Ajout documentation OpenAPI |
+| `pmoapp/webapp/src/services/pmocontrol/api.ts` | Ajout méthode API `shuffleQueue()` |
+| `pmoapp/webapp/src/components/unified/BottomTabBar.vue` | Intégration du bouton shuffle |
+
+## Fichiers créés
+
+| Fichier | Description |
+|---------|-------------|
+| `pmoapp/webapp/src/components/pmocontrol/ShuffleControl.vue` | Composant Vue.js du bouton shuffle |
+
+## Notes techniques
+
+- La méthode `shuffle_queue` détache automatiquement la playlist liée pour éviter que la queue soit écrasée par une mise à jour de la playlist
+- Le shuffle utilise `rand::thread_rng()` pour une génération aléatoire de qualité
+- L'endpoint REST utilise le même pattern async que les autres commandes de transport (spawn_blocking + timeout)
+- Le timeout utilisé est `QUEUE_COMMAND_TIMEOUT` (10 secondes)
+- L'émission des événements SSE est automatique via le `RendererEventBus` intégré au `MusicRenderer`
+- L'implémentation manuelle de `Debug` pour `MusicRenderer` est nécessaire car `RendererEventBus` n'implémente pas `Debug`
+- Les événements ne sont émis que lorsqu'il y a un changement effectif (pas d'événement `BindingChanged` si le binding était déjà `None`)
+
+## Améliorations architecturales
+
+Ce travail a posé les bases d'une meilleure architecture où le `MusicRenderer` est responsable de l'émission de ses propres événements. Une tâche de suivi a été créée (`Blackboard/Todo/stateful_music_renderer.md`) pour aller plus loin et rendre le `MusicRenderer` complètement stateful avec son propre thread de surveillance.

Blackboard/Done/stateful_music_renderer.md

@@ -0,0 +1,114 @@
+# Tâche terminée : Rendre MusicRenderer complètement stateful
+
+## Objectif
+
+Refactoriser l'architecture pour que chaque `MusicRenderer` gère son propre thread de surveillance (watcher), au lieu de déléguer le polling au `ControlPoint` centralisé.
+
+## Motivation
+
+1. **Encapsulation** - Tout l'état et le comportement d'un renderer au même endroit
+2. **Cohérence** - Les événements sont émis là où l'état change
+3. **Adaptabilité par backend** - Chaque backend peut avoir sa propre stratégie de surveillance (polling vs push)
+4. **Auto-advance spécifique** - La logique d'auto-advance peut être adaptée par backend
+5. **Simplicité du ControlPoint** - Il devient un simple registry/coordinateur
+
+---
+
+## Résumé de l'implémentation
+
+### Fichiers créés
+
+| Fichier | Description |
+|---------|-------------|
+| `pmocontrol/src/music_renderer/watcher.rs` | Module watcher avec `WatchStrategy`, `WatchedState` et fonctions helper |
+
+### Fichiers modifiés
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Champs watcher, méthodes `start/stop_watching()`, logique auto-advance, gestion automatique dans constructeur et `DeviceOnline` |
+| `pmocontrol/src/music_renderer/mod.rs` | Export du module `watcher` |
+| `pmocontrol/src/registry.rs` | Simplifié : plus d'appels manuels watcher |
+| `pmocontrol/src/control_point.rs` | Suppression polling central (~140 lignes), `RendererRuntimeSnapshot`, `handle_renderer_event()` |
+
+---
+
+## Architecture finale
+
+### WatchStrategy
+
+```rust
+pub enum WatchStrategy {
+    Polling { interval_ms: u64 },      // UPnP, LinkPlay, Arylic (500ms)
+    Push,                               // Futur : notifications push
+    Hybrid { polling_interval_ms: u64 }, // OpenHome, Chromecast
+}
+```
+
+### Gestion automatique du watcher
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    GESTION AUTOMATIQUE DU WATCHER               │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Création MusicRenderer ──► constructeur ──► start_watching()   │
+│                                                                  │
+│  has_been_seen_now() ──► si !was_online ──► start_watching()    │
+│                                                                  │
+│  mark_as_offline() ──► stop_watching() ──► online = false       │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Flux offline/online
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         FLUX ONLINE                              │
+├─────────────────────────────────────────────────────────────────┤
+│  SSDP Discovery ──► push_renderer() ──► constructeur            │
+│                                          ──► start_watching()   │
+│                                                                  │
+│  SSDP Alive (offline→online) ──► has_been_seen_now()            │
+│                                   ──► start_watching()          │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│                         FLUX OFFLINE                             │
+├─────────────────────────────────────────────────────────────────┤
+│  SSDP ByeBye / Timeout ──► mark_as_offline()                    │
+│                             ──► stop_watching()                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Points techniques clés
+
+- **Thread safety** : `AtomicBool` avec `Ordering::SeqCst` pour le signal d'arrêt
+- **Idempotence** : `start_watching()` et `stop_watching()` sont idempotents
+- **Nommage** : Thread nommé `watcher-{friendly_name}` pour debug
+- **Polling** : 500ms pour position/état, 1s pour volume/mute
+- **Auto-advance** : Géré dans `handle_state_change()` du MusicRenderer
+- **Compensation bugs** : `compute_logical_playback_state()` corrige les comportements Arylic/LinkPlay
+
+---
+
+## Rounds de vérification
+
+| Round | Objectif | Résultat |
+|-------|----------|----------|
+| 1 | Implémentation initiale | OK |
+| 2 | Vérifier transition offline→online | Bug trouvé et corrigé dans `refresh_device_presence()` |
+| 3 | Audit complet des chemins offline/online | Tous les chemins vérifiés OK |
+| 4 | Centralisation dans `MusicRenderer` | Gestion automatique dans constructeur et `DeviceOnline` |
+
+---
+
+## Conclusion
+
+L'architecture est maintenant plus robuste :
+- Impossible d'oublier de démarrer/arrêter le watcher
+- Le `registry.rs` est simplifié
+- Préparation pour le support futur des notifications push (OpenHome, Chromecast)

Blackboard/Report/Bug_lecture_open_home.md

@@ -0,0 +1,76 @@
+# Rapport : Bug de duplication de piste en position 0
+
+## Résumé
+
+Correction d'un bug où la piste en cours de lecture était dupliquée en position 0 de la queue après un certain temps.
+
+## Problème identifié
+
+### Symptôme
+Lors de la lecture d'une playlist liée à une queue (OpenHome ou interne), après le passage à une nouvelle piste, celle-ci finissait par être dupliquée en première position de la queue.
+
+### Cause racine
+La fonction `sync_queue` (utilisée lors des refreshes périodiques de playlist toutes les 60 secondes) comparait les items uniquement par leur URI. Si le MediaServer retournait une URI légèrement différente pour le même morceau (tokens de session, encodage différent, etc.), l'item courant n'était pas reconnu dans la nouvelle playlist et était préservé en position 0, créant ainsi une duplication.
+
+### Mécanisme détaillé
+1. Une playlist est attachée à un renderer
+2. La lecture commence sur la piste N
+3. Après 60 secondes, un refresh périodique déclenche `sync_queue`
+4. `sync_queue` compare l'URI de la piste courante avec les URIs de la playlist rafraîchie
+5. Si les URIs ne correspondent pas exactement, la piste courante est considérée comme "absente" de la playlist
+6. La logique de préservation insère alors la piste courante en position 0
+7. Résultat : duplication de la piste
+
+## Solution appliquée
+
+### Modification de la logique de comparaison
+
+La comparaison des items a été étendue pour utiliser l'URI **OU** le `didl_id` comme critère d'identification. Le `didl_id` est l'identifiant DIDL-Lite stable assigné par le MediaServer, indépendant de l'URI de streaming.
+
+### Fichiers modifiés
+
+#### 1. `pmocontrol/src/queue/interne.rs`
+
+- Ajout de la comparaison par `didl_id` en fallback dans `sync_queue`
+- Ajout de logs de diagnostic pour tracer les cas de non-correspondance
+
+```rust
+// Avant
+let new_idx = items.iter().position(|item| item.uri == current_uri);
+
+// Après
+let new_idx = items.iter().position(|item| item.uri == current_uri)
+    .or_else(|| items.iter().position(|item| item.didl_id == current_didl_id));
+```
+
+#### 2. `pmocontrol/src/queue/openhome.rs`
+
+- Ajout de la fonction `items_match` pour encapsuler la logique de comparaison
+- Modification de `sync_queue` pour utiliser URI ou `didl_id`
+- Modification de `lcs_flags` (algorithme LCS) pour utiliser la même logique de comparaison
+
+```rust
+fn items_match(a: &PlaybackItem, b: &PlaybackItem) -> bool {
+    a.uri == b.uri || a.didl_id == b.didl_id
+}
+```
+
+## Tests recommandés
+
+1. Attacher une playlist à un renderer OpenHome
+2. Lancer la lecture
+3. Attendre plusieurs cycles de refresh (> 60 secondes)
+4. Vérifier que la queue ne contient pas de duplications
+5. Cliquer sur différentes pistes et vérifier le même comportement
+
+## Diagnostic
+
+Pour activer les logs de diagnostic :
+
+```bash
+RUST_LOG=pmocontrol::queue=debug
+```
+
+Les messages suivants permettent de tracer le comportement :
+- `sync_queue: current item found in new playlist` - Comportement normal
+- `sync_queue: current item NOT found in new playlist, preserving as first item` - Cas problématique (ne devrait plus apparaître avec le fix)

Blackboard/Report/Oubli_Main_Radio.md

@@ -0,0 +1,64 @@
+# Rapport : Correction de l'affichage des groupes de radios
+
+## Résumé
+
+Correction des deux bugs identifiés dans l'organisation des groupes de stations Radio France :
+1. La radio principale était absente des groupes multi-stations (écrasée par les webradios)
+2. Le groupe ICI (radios locales) était inaccessible à cause d'une station virtuelle "ici" mal gérée
+
+## Solution implémentée
+
+Refactoring complet pour supprimer la notion de "station virtuelle" et utiliser des champs optionnels `group_name` et `group_slug` dans `StationGroup`.
+
+### Modifications
+
+**Fichiers modifiés :**
+- `pmoradiofrance/src/playlist.rs`
+- `pmoradiofrance/src/source.rs`
+- `pmoradiofrance/src/client.rs`
+
+### Changements structurels
+
+1. **Ajout de champs optionnels à `StationGroup`** :
+   - `group_name: Option<String>` : nom personnalisé du groupe (pour ICI : "Radios ICI")
+   - `group_slug: Option<String>` : slug personnalisé du groupe (pour ICI : "ici")
+
+2. **Suppression de la station virtuelle "ici"** :
+   - Plus de création d'une `Station { slug: "ici", name: "Radios ICI" }`
+   - Le groupe ICI contient maintenant uniquement les vraies stations `francebleu_*`
+
+3. **Méthodes helper dans `StationGroup`** :
+   - `name()` : retourne `group_name` ou le nom de `stations[0]`
+   - `slug()` : retourne `group_slug` ou le slug de `stations[0]`
+
+4. **Simplification de la logique** :
+   - `to_stub()` et `to_didl()` de `StationGroup` utilisent `self.name()` et `self.slug()`
+   - Plus de traitement spécial pour détecter ou sauter la station virtuelle "ici"
+   - `compute_parent_id()` de `Station` utilise le slug fixe "ici" pour les stations `francebleu_*`
+
+5. **Tri alphabétique des stations** :
+   - Dans chaque groupe : station principale en position 0, puis webradios triées par nom
+   - Groupe ICI : toutes les stations triées par nom (pas de station principale)
+   - Les stations se retrouvent toujours à la même position dans la liste
+
+6. **Chargement parallèle des métadonnées** :
+   - Utilisation de `futures::stream::buffer_unordered(5)` pour charger jusqu'à 5 stations en parallèle
+   - Décalage de 50ms entre chaque requête pour éviter de surcharger l'API Radio France
+   - Amélioration significative du temps de chargement des groupes multi-stations
+
+7. **Filtrage de francebleu générique** :
+   - Application de la règle métier : `francebleu` (sans suffixe) n'est pas une vraie station
+   - Filtrage dans `discover_all_stations()` pour éviter qu'elle soit ajoutée à la liste
+   - Utilisation de `group.slug()` au lieu de `stations[0].slug` dans `source.rs` pour gérer correctement le groupe ICI
+
+### Résultat
+
+- **Groupes avec radio principale** (FIP, France Inter, etc.) : la radio principale apparaît à l'index 0, suivie des webradios triées alphabétiquement
+- **Groupe ICI** : accessible et affiche toutes les radios locales triées alphabétiquement
+- Code plus simple et sans logique spéciale dispersée
+- Interface prévisible : les stations sont toujours au même endroit
+- **Chargement plus rapide** : les métadonnées sont récupérées en parallèle au lieu de séquentiellement
+
+## Statut
+
+Modifications terminées. Compilation à vérifier par l'utilisateur.

Blackboard/Report/Pinnable_cache_item.md

@@ -0,0 +1,390 @@
+# Rapport : Implémentation des items épinglables dans PMOcache
+
+## Résumé
+
+Implémentation réussie de la fonctionnalité d'items épinglables dans la crate PMOcache, permettant de protéger certains items de l'éviction automatique par la politique LRU. Cette fonctionnalité inclut également un système de TTL (Time To Live) avec une règle métier empêchant qu'un item soit à la fois épinglé et avec un TTL.
+
+## Modifications apportées
+
+### 1. Structure de la base de données (`pmocache/src/db.rs`)
+
+#### Modification du schéma de la table `asset`
+
+Ajout de deux nouvelles colonnes :
+
+```sql
+CREATE TABLE IF NOT EXISTS asset (
+    pk TEXT PRIMARY KEY,
+    collection TEXT,
+    id TEXT,
+    hits INTEGER DEFAULT 0,
+    last_used TEXT,
+    lazy_pk TEXT,
+    pinned INTEGER DEFAULT 0 CHECK (pinned IN (0, 1)),
+    ttl_expires_at TEXT
+)
+```
+
+- **`pinned`** : Booléen (0 ou 1) indiquant si l'item est épinglé
+- **`ttl_expires_at`** : Date/heure d'expiration au format RFC3339 (optionnel)
+
+#### Mise à jour de la structure `CacheEntry`
+
+Ajout des champs correspondants :
+
+```rust
+pub struct CacheEntry {
+    // ... champs existants ...
+    pub pinned: bool,
+    pub ttl_expires_at: Option<String>,
+    // ...
+}
+```
+
+#### Nouvelles méthodes dans `DB`
+
+##### Gestion du comptage
+
+- **`count_unpinned()`** : Compte uniquement les items non épinglés
+  - Les items épinglés ne comptent pas dans la limite du cache
+
+##### Gestion du pinning
+
+- **`pin(pk: &str)`** : Épingle un item
+  - Vérifie que l'item n'a pas de TTL défini (règle métier)
+  - Retourne une erreur si le TTL est déjà défini
+  
+- **`unpin(pk: &str)`** : Désépingle un item
+
+- **`is_pinned(pk: &str)`** : Vérifie si un item est épinglé
+
+##### Gestion du TTL
+
+- **`set_ttl(pk: &str, expires_at: &str)`** : Définit le TTL d'un item
+  - Vérifie que l'item n'est pas épinglé (règle métier)
+  - Retourne une erreur si l'item est épinglé
+  
+- **`clear_ttl(pk: &str)`** : Supprime le TTL d'un item
+
+- **`get_expired()`** : Récupère tous les items dont le TTL est dépassé
+
+##### Modification de `get_oldest()`
+
+La requête SQL exclut maintenant les items épinglés :
+
+```sql
+SELECT ... FROM asset
+WHERE pinned = 0
+ORDER BY last_used ASC, hits ASC
+LIMIT ?1
+```
+
+### 2. Logique du cache (`pmocache/src/cache.rs`)
+
+#### Méthodes publiques ajoutées
+
+```rust
+pub async fn pin(&self, pk: &str) -> Result<()>
+pub async fn unpin(&self, pk: &str) -> Result<()>
+pub async fn is_pinned(&self, pk: &str) -> Result<bool>
+pub async fn set_ttl(&self, pk: &str, expires_at: &str) -> Result<()>
+pub async fn clear_ttl(&self, pk: &str) -> Result<()>
+```
+
+#### Modification de `enforce_limit()`
+
+La politique d'éviction a été améliorée :
+
+1. **Suppression prioritaire des items expirés** : Les items dont le TTL est dépassé sont supprimés en premier
+2. **Comptage des items non épinglés** : Utilise `count_unpinned()` au lieu de `count()`
+3. **Protection des items épinglés** : Ils ne peuvent pas être évincés par LRU
+4. **Logging amélioré** : Messages distincts pour les items expirés et l'éviction LRU
+
+### 3. Tests (`pmocache/tests/test_pinnable.rs`)
+
+Création d'une suite complète de tests (9 tests, tous passants) :
+
+1. **`test_pin_unpin`** : Vérifie l'épinglage et le désépinglage basiques
+2. **`test_pinned_excluded_from_lru`** : Vérifie que les items épinglés ne sont pas évincés
+3. **`test_pinned_count_separately`** : Vérifie le comptage séparé des items épinglés
+4. **`test_cannot_pin_with_ttl`** : Vérifie la règle métier TTL → pas de pinning
+5. **`test_cannot_set_ttl_when_pinned`** : Vérifie la règle métier pinned → pas de TTL
+6. **`test_ttl_expiration`** : Vérifie la suppression automatique des items expirés
+7. **`test_clear_ttl`** : Vérifie la suppression du TTL
+8. **`test_get_expired`** : Vérifie la récupération des items expirés
+9. **`test_cache_entry_fields`** : Vérifie les valeurs des champs dans `CacheEntry`
+
+## Règles métier implémentées
+
+### Incompatibilité TTL ↔ Pinned
+
+Un item ne peut pas être à la fois épinglé ET avoir un TTL :
+
+- **Si TTL défini** : `pin()` retourne une erreur
+- **Si épinglé** : `set_ttl()` retourne une erreur
+
+Cette règle garantit une sémantique claire :
+- **Épinglé** = permanent, protégé de l'éviction
+- **TTL** = temporaire, sera supprimé à expiration
+
+### Comptage des items
+
+Les items épinglés sont **exclus** du comptage de la limite du cache :
+
+- Un cache de limite 100 peut contenir 100 items non épinglés + N items épinglés
+- Seuls les items non épinglés sont pris en compte pour l'éviction LRU
+
+### Ordre de suppression lors de `enforce_limit()`
+
+1. **Items expirés (TTL dépassé)** : supprimés en priorité
+2. **Items LRU** : si la limite est toujours dépassée, suppression des plus vieux items **non épinglés**
+
+## Compatibilité
+
+### Migration de base de données
+
+**Aucune migration nécessaire** : Les colonnes `pinned` et `ttl_expires_at` ont des valeurs par défaut :
+- `pinned = 0` (non épinglé)
+- `ttl_expires_at = NULL` (pas de TTL)
+
+Les bases existantes seront automatiquement mises à jour au prochain démarrage via le `CREATE TABLE IF NOT EXISTS` avec les nouvelles colonnes.
+
+### Rétrocompatibilité du code
+
+Toutes les méthodes existantes continuent de fonctionner sans modification :
+- Les items existants ne sont pas épinglés par défaut
+- Le comportement LRU standard reste identique pour les items non épinglés
+
+## Exemples d'utilisation
+
+### Utilisation programmatique (Rust)
+
+```rust
+use pmocache::{Cache, CacheConfig};
+use chrono::{Duration, Utc};
+
+// Créer un cache
+let cache = Cache::<MyConfig>::new("./cache", 100).unwrap();
+
+// Ajouter un fichier
+let pk = cache.add_from_url("https://example.com/file.dat", None).await?;
+
+// Épingler pour protéger de l'éviction
+cache.pin(&pk).await?;
+
+// Ou définir un TTL de 24 heures
+let expires_at = (Utc::now() + Duration::hours(24)).to_rfc3339();
+cache.set_ttl(&pk2, &expires_at).await?;
+
+// Vérifier le statut
+if cache.is_pinned(&pk).await? {
+    println!("Fichier protégé");
+}
+```
+
+### Utilisation via l'API REST
+
+#### Récupérer le statut de pinning
+
+```bash
+GET /api/cache/{pk}/pin
+
+Response 200 OK:
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "pinned": false,
+  "ttl_expires_at": null
+}
+```
+
+#### Épingler un item
+
+```bash
+POST /api/cache/{pk}/pin
+
+Response 200 OK:
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "message": "Item '1a2b3c4d5e6f7a8b' pinned successfully"
+}
+
+Response 409 CONFLICT (si TTL défini):
+{
+  "error": "CONFLICT",
+  "message": "Cannot pin an item with TTL set. Clear TTL first."
+}
+```
+
+#### Désépingler un item
+
+```bash
+DELETE /api/cache/{pk}/pin
+
+Response 200 OK:
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "message": "Item '1a2b3c4d5e6f7a8b' unpinned successfully"
+}
+```
+
+#### Définir un TTL
+
+```bash
+POST /api/cache/{pk}/ttl
+Content-Type: application/json
+
+{
+  "expires_at": "2025-01-20T10:30:00Z"
+}
+
+Response 200 OK:
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "message": "TTL set successfully for item '1a2b3c4d5e6f7a8b'"
+}
+
+Response 409 CONFLICT (si épinglé):
+{
+  "error": "CONFLICT",
+  "message": "Cannot set TTL on a pinned item. Unpin first."
+}
+
+Response 400 BAD REQUEST (format invalide):
+{
+  "error": "INVALID_DATE",
+  "message": "Invalid RFC3339 date format"
+}
+```
+
+#### Supprimer un TTL
+
+```bash
+DELETE /api/cache/{pk}/ttl
+
+Response 200 OK:
+{
+  "pk": "1a2b3c4d5e6f7a8b",
+  "message": "TTL cleared successfully for item '1a2b3c4d5e6f7a8b'"
+}
+```
+
+## Fichiers modifiés
+
+### Phase 1 : Implémentation de base
+
+1. **`pmocache/src/db.rs`** :
+   - Modification du schéma SQL
+   - Ajout de champs dans `CacheEntry`
+   - Ajout de 8 nouvelles méthodes
+   - Modification de `get_oldest()`, `get()`, `get_from_id()`, `get_all()`, `get_by_collection()`
+
+2. **`pmocache/src/cache.rs`** :
+   - Ajout de 5 méthodes publiques
+   - Modification de `enforce_limit()`
+
+3. **`pmocache/tests/test_pinnable.rs`** :
+   - Nouveau fichier de tests (9 tests)
+
+### Phase 2 : Enrichissement de l'API REST
+
+4. **`pmocache/src/api.rs`** :
+   - Ajout de 3 nouvelles structures de données : `SetTtlRequest`, `PinResponse`, `PinStatus`
+   - Ajout de 5 nouveaux handlers d'API :
+     - `get_pin_status()` : Récupération du statut de pinning
+     - `pin_item()` : Épinglage d'un item
+     - `unpin_item()` : Désépinglage d'un item
+     - `set_item_ttl()` : Définition du TTL
+     - `clear_item_ttl()` : Suppression du TTL
+
+5. **`pmocache/src/pmoserver_ext.rs`** :
+   - Ajout de 4 nouvelles routes dans `create_api_router()` :
+     - `GET /{pk}/pin` : Statut de pinning
+     - `POST /{pk}/pin` : Épingler
+     - `DELETE /{pk}/pin` : Désépingler
+     - `POST /{pk}/ttl` : Définir TTL
+     - `DELETE /{pk}/ttl` : Supprimer TTL
+
+6. **`pmocache/src/openapi.rs`** :
+   - Mise à jour de la macro `create_cache_openapi!` pour inclure :
+     - Les 5 nouveaux endpoints dans la documentation
+     - Les 3 nouvelles structures dans les schémas OpenAPI
+
+7. **`pmocache/src/lib.rs`** :
+   - Export des nouvelles structures publiques pour l'API
+
+## API REST et Documentation OpenAPI
+
+### Routes disponibles
+
+Toutes les routes sont préfixées par `/api/{cache_name}/` (ex: `/api/covers/`, `/api/audio/`).
+
+| Méthode | Route | Description |
+|---------|-------|-------------|
+| `GET` | `/{pk}/pin` | Récupère le statut de pinning d'un item |
+| `POST` | `/{pk}/pin` | Épingle un item (le protège de l'éviction LRU) |
+| `DELETE` | `/{pk}/pin` | Désépingle un item |
+| `POST` | `/{pk}/ttl` | Définit le TTL d'un item (expiration automatique) |
+| `DELETE` | `/{pk}/ttl` | Supprime le TTL d'un item |
+
+### Codes de statut HTTP
+
+| Code | Signification | Cas d'usage |
+|------|--------------|-------------|
+| `200 OK` | Opération réussie | Tous les cas de succès |
+| `400 BAD REQUEST` | Requête invalide | Format de date TTL invalide |
+| `404 NOT FOUND` | Item non trouvé | PK inexistant dans le cache |
+| `409 CONFLICT` | Conflit de règle métier | Tentative de pin avec TTL ou vice-versa |
+| `500 INTERNAL SERVER ERROR` | Erreur serveur | Erreur de base de données |
+
+### Documentation OpenAPI/Swagger
+
+La documentation OpenAPI est automatiquement générée et inclut :
+
+- **Schémas de données** :
+  - `PinStatus` : Statut de pinning (pinned, ttl_expires_at)
+  - `PinResponse` : Réponse d'opération de pinning
+  - `SetTtlRequest` : Requête de définition de TTL
+  - `CacheEntry` : Mis à jour avec les champs `pinned` et `ttl_expires_at`
+
+- **Endpoints documentés** :
+  - Description détaillée de chaque route
+  - Exemples de requêtes et réponses
+  - Codes d'erreur possibles
+
+- **Interface Swagger UI** :
+  - Accessible à `/swagger-ui/{cache_name}`
+  - Permet de tester l'API directement depuis le navigateur
+
+### Gestion des erreurs
+
+L'API suit une structure d'erreur cohérente :
+
+```json
+{
+  "error": "CODE_ERREUR",
+  "message": "Description lisible de l'erreur"
+}
+```
+
+Les règles métier sont appliquées strictement :
+- **409 CONFLICT** si tentative de pin avec TTL défini
+- **409 CONFLICT** si tentative de set TTL sur item épinglé
+- Messages d'erreur explicites guidant l'utilisateur
+
+## Tests
+
+- **Suite de tests dédiée** : 9 tests, tous passants
+- **Tests existants** : Tous les tests de `test_cache.rs` passent toujours
+- **Couverture** : Toutes les nouvelles fonctionnalités sont testées
+- **Compilation** : Aucune erreur, tous les modules compilent correctement
+
+## Résultat
+
+✅ **Implémentation complète et fonctionnelle** des items épinglables avec TTL  
+✅ **Règle métier** TTL ↔ Pinned correctement implémentée  
+✅ **Tests exhaustifs** validant tous les cas d'usage  
+✅ **Compatibilité** avec les bases de données existantes  
+✅ **Pas de régression** sur les tests existants  
+✅ **API REST complète** avec 5 nouveaux endpoints  
+✅ **Documentation OpenAPI** automatiquement générée  
+✅ **Gestion d'erreurs cohérente** avec codes HTTP appropriés

Blackboard/Report/WeabApp_debouncingSSE.md

@@ -0,0 +1,152 @@
+# Rapport : Suppression de la logique de débouncing SSE
+
+**Date**: 2026-01-12
+**Tâche**: WeabApp_debouncingSSE.md
+
+## Objectif
+
+Supprimer la logique de débouncing inutile sur le canal SSE de l'application web PMOControl, puisque le serveur contrôle déjà le flux des événements.
+
+## Analyse préalable
+
+J'ai identifié trois endroits avec des mécanismes de temporisation dans l'application web :
+
+### 1. MediaBrowser.vue - Débouncing SSE (À SUPPRIMER ✓)
+- **Débouncing**: 200ms après invalidation du cache
+- **Cooldown**: 2 secondes entre les rechargements
+- **Justification originale**: "dédupliquer les événements SSE dans le même batch (polling 500ms)"
+- **Problème**: Cette logique est redondante puisque le serveur contrôle déjà le flux SSE
+
+### 2. useRenderers.ts - Smart fetching (À CONSERVER ✓)
+- **Mécanisme**: Comparaison des timestamps `lastEventAt` vs `lastSnapshotAt`
+- **But**: Éviter de refetch un snapshot déjà à jour
+- **Justification**: Ce n'est PAS du débouncing, c'est une optimisation intelligente qui évite des appels API inutiles
+
+### 3. VolumeControl.vue - UI debouncing (À CONSERVER ✓)
+- **Débouncing**: 300ms sur les changements de volume
+- **But**: Réduire les appels API pendant que l'utilisateur fait glisser le curseur
+- **Justification**: Débouncing légitime pour l'interface utilisateur
+
+## Modifications effectuées
+
+### Fichier modifié: `pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue`
+
+#### 1. Suppression des variables de débouncing (ligne ~27)
+
+**Avant**:
+```typescript
+// Flags pour gérer le rechargement automatique avec debounce et cooldown
+const isRefreshing = ref(false);
+const refreshTimeoutId = ref<number | null>(null);
+const lastRefreshTime = ref<number>(0);
+const REFRESH_COOLDOWN_MS = 2000; // Ne pas recharger plus d'une fois toutes les 2 secondes
+```
+
+**Après**:
+```typescript
+// Flag pour gérer le rechargement automatique
+const isRefreshing = ref(false);
+```
+
+#### 2. Simplification du watcher de cache (ligne ~53)
+
+**Avant**:
+```typescript
+// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)
+// Cela se produit notamment quand on clique sur "Lire maintenant" sur une playlist,
+// ce qui déclenche un événement ContainersUpdated qui invalide le cache
+// Utilise un debounce de 3 secondes pour regrouper les multiples invalidations
+// et un cooldown de 5 secondes pour éviter les rechargements successifs
+watch(
+    () => browseData.value,
+    (data) => {
+        if (!data && props.containerId && !loading.value) {
+            // Vérifier le cooldown: ignorer si on a rechargé il y a moins de 5 secondes
+            const timeSinceLastRefresh = Date.now() - lastRefreshTime.value;
+            if (timeSinceLastRefresh < REFRESH_COOLDOWN_MS) {
+                console.log(
+                    `[MediaBrowser] Cache invalidé mais cooldown actif (${Math.round((REFRESH_COOLDOWN_MS - timeSinceLastRefresh) / 1000)}s restantes), rechargement ignoré`,
+                );
+                return;
+            }
+
+            // Annuler tout timeout en cours
+            if (refreshTimeoutId.value !== null) {
+                clearTimeout(refreshTimeoutId.value);
+            }
+
+            // Planifier le rechargement après 200ms
+            refreshTimeoutId.value = window.setTimeout(async () => {
+                if (!isRefreshing.value) {
+                    console.log(
+                        `[MediaBrowser] Cache invalidé pour ${props.serverId}/${props.containerId}, rechargement après debounce...`,
+                    );
+                    isRefreshing.value = true;
+                    await browseContainer(
+                        props.serverId,
+                        props.containerId,
+                        false,
+                    );
+                    lastRefreshTime.value = Date.now();
+                    isRefreshing.value = false;
+                    refreshTimeoutId.value = null;
+                }
+            }, 200);
+        }
+    },
+);
+```
+
+**Après**:
+```typescript
+// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)
+// Cela se produit notamment quand on clique sur "Lire maintenant" sur une playlist,
+// ce qui déclenche un événement ContainersUpdated qui invalide le cache
+// Le serveur contrôle déjà le flux SSE, pas besoin de debouncing côté client
+watch(
+    () => browseData.value,
+    async (data) => {
+        // Si browseData devient undefined alors que containerId est présent,
+        // et qu'on n'est pas déjà en train de charger, recharger immédiatement
+        if (!data && props.containerId && !loading.value && !isRefreshing.value) {
+            console.log(
+                `[MediaBrowser] Cache invalidé pour ${props.serverId}/${props.containerId}, rechargement...`,
+            );
+            isRefreshing.value = true;
+            await browseContainer(props.serverId, props.containerId, false);
+            isRefreshing.value = false;
+        }
+    },
+);
+```
+
+## Résultats
+
+### Changements de comportement
+- **Avant**: Délai de 200ms + cooldown de 2s entre les rechargements de cache
+- **Après**: Rechargement immédiat dès l'invalidation du cache
+- **Impact**: Réactivité améliorée de l'interface, les mises à jour apparaissent immédiatement
+
+### Réduction de complexité
+- **3 variables supprimées**: `refreshTimeoutId`, `lastRefreshTime`, `REFRESH_COOLDOWN_MS`
+- **Logique simplifiée**: De ~40 lignes à ~10 lignes dans le watcher
+- **Code plus lisible**: Intention claire sans mécanismes de temporisation complexes
+
+### Tests
+- ✓ Le projet compile sans erreurs TypeScript
+- ✓ Le flag `isRefreshing` empêche toujours les rechargements concurrents
+- ✓ Les autres composants (useRenderers.ts, VolumeControl.vue) conservent leurs optimisations légitimes
+
+## Conclusion
+
+La suppression du débouncing et du cooldown dans MediaBrowser.vue simplifie le code tout en améliorant la réactivité de l'interface. Puisque le serveur contrôle déjà le flux SSE, ces mécanismes côté client étaient redondants et ajoutaient une latence artificielle.
+
+Le code est maintenant plus simple, plus réactif, et fait confiance au serveur pour contrôler la fréquence des événements SSE.
+
+## Fichiers modifiés
+- `pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue`
+
+## Lignes de code
+- **Supprimées**: ~35 lignes (logique de débouncing/cooldown)
+- **Ajoutées**: ~5 lignes (logique simplifiée)
+- **Net**: -30 lignes

Blackboard/Report/bug_images_cache_webapp.md

@@ -0,0 +1,134 @@
+# Rapport : Correction du bug d'affichage des images en cache dans la webapp
+
+## Tâche originale
+
+Les images de couverture d'album ne s'affichaient plus dans l'application web Control Point. Seuls les logos SVG de fallback étaient visibles, bien que les URLs soient correctes et les images accessibles.
+
+## Analyse
+
+### Pattern d'affichage existant
+
+Les composants utilisaient le pattern suivant :
+
+```vue
+<img
+    v-if="item.album_art_uri && !imageError"
+    v-show="imageLoaded"
+    :src="item.album_art_uri"
+    @load="handleImageLoad"
+    @error="handleImageError"
+/>
+<div v-if="!item.album_art_uri || imageError || !imageLoaded" class="placeholder">
+    <Music :size="20" />
+</div>
+```
+
+Avec :
+```typescript
+const imageLoaded = ref(false);
+
+watch(() => props.item.album_art_uri, () => {
+    imageLoaded.value = false;
+    imageError.value = false;
+});
+
+function handleImageLoad() {
+    imageLoaded.value = true;
+}
+```
+
+### Cause du bug
+
+Lorsqu'une image est **déjà en cache du navigateur**, elle peut se charger de manière **synchrone** avant que Vue n'ait attaché l'écouteur d'événement `@load`. Dans ce cas :
+
+1. L'image est créée dans le DOM (via `v-if`)
+2. Le navigateur charge l'image immédiatement depuis le cache
+3. L'événement `load` se déclenche **avant** que Vue n'ait attaché `@load`
+4. `imageLoaded` reste à `false`
+5. L'image reste cachée par `v-show="imageLoaded"`
+6. Le placeholder SVG s'affiche à la place
+
+Ce comportement est particulièrement fréquent avec des images déjà visitées ou après un rechargement de page.
+
+## Correction appliquée
+
+### Solution
+
+Ajout d'une fonction `checkImageComplete()` qui vérifie si l'image est déjà chargée via les propriétés natives de l'élément `<img>` :
+
+```typescript
+const coverImageRef = ref<HTMLImageElement | null>(null);
+
+function checkImageComplete() {
+    nextTick(() => {
+        if (coverImageRef.value?.complete && coverImageRef.value?.naturalWidth > 0) {
+            imageLoaded.value = true;
+            imageError.value = false;
+        }
+    });
+}
+
+onMounted(() => {
+    checkImageComplete();
+});
+
+watch(() => metadata.value?.album_art_uri, (newUri) => {
+    imageLoaded.value = false;
+    imageError.value = false;
+    if (newUri) {
+        checkImageComplete();
+    }
+});
+```
+
+Et ajout de la référence sur l'élément `<img>` :
+
+```vue
+<img ref="coverImageRef" ... />
+```
+
+### Fichiers modifiés
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmoapp/webapp/src/components/pmocontrol/CurrentTrack.vue` | Ajout `checkImageComplete()`, `coverImageRef`, `onMounted` |
+| `pmoapp/webapp/src/components/pmocontrol/QueueItem.vue` | Ajout `checkImageComplete()`, `coverImageRef`, `onMounted` |
+| `pmoapp/webapp/src/components/pmocontrol/MediaItem.vue` | Ajout `checkImageComplete()`, `coverImageRef`, `onMounted` |
+| `pmoapp/webapp/src/components/pmocontrol/RendererCard.vue` | Ajout complet de la gestion d'état image (était absent) |
+
+### Détail des modifications par composant
+
+#### CurrentTrack.vue
+- Import de `onMounted`, `nextTick`
+- Ajout de `coverImageRef`
+- Ajout de `checkImageComplete()`
+- Modification du `watch` pour appeler `checkImageComplete()` après changement d'URL
+- Ajout de `onMounted(() => checkImageComplete())`
+- Ajout de `ref="coverImageRef"` sur l'élément `<img>`
+
+#### QueueItem.vue
+- Mêmes modifications que CurrentTrack.vue
+
+#### MediaItem.vue
+- Mêmes modifications que CurrentTrack.vue
+
+#### RendererCard.vue
+- Ce composant n'avait pas de gestion d'état de chargement d'image
+- Ajout complet : `imageLoaded`, `imageError`, `coverImageRef`, `checkImageComplete()`
+- Ajout des handlers `@load` et `@error`
+- Modification de `hasCover` pour inclure `!imageError`
+- Ajout de `v-show="imageLoaded"` sur l'image
+- Modification de la condition du placeholder
+
+## Vérification
+
+- Build webpack réussi sans erreur
+- Compilation TypeScript OK
+
+## Remarque technique
+
+La propriété `HTMLImageElement.complete` retourne `true` si :
+- L'image a fini de charger (succès ou erreur)
+- L'attribut `src` est vide ou absent
+
+C'est pourquoi on vérifie également `naturalWidth > 0` pour s'assurer que l'image a bien été chargée avec succès (une image en erreur a `naturalWidth === 0`).

Blackboard/Report/bug_lecture_queue_interne.md

@@ -0,0 +1,79 @@
+# Rapport : Correction du bug de lecture sur queue interne
+
+## Problème
+
+Lors de la lecture sur un Renderer avec queue interne, si l'utilisateur clique sur un item de la queue pour déclencher sa lecture, tout semble se passer normalement pendant une seconde. Puis, avant que la lecture ne démarre réellement, le lecteur passe à la piste suivante.
+
+## Analyse
+
+### Cause identifiée
+
+Le problème était une **race condition** dans la logique d'auto-advance du watcher.
+
+Quand l'utilisateur clique sur un item de la queue :
+1. `play_queue_index` est appelé dans `ControlPoint`
+2. Les commandes UPnP `SetAVTransportURI` + `Play` sont envoyées au renderer
+3. Le renderer peut passer brièvement par un état `STOPPED` pendant l'initialisation de la nouvelle piste
+4. Le watcher (polling toutes les 500ms) détecte cet état `STOPPED`
+5. Comme la lecture était lancée depuis la queue (`PlaybackSource::FromQueue`), l'auto-advance se déclenche et passe à la piste suivante
+
+### Détail technique
+
+La logique d'auto-advance dans `handle_state_change` vérifie si `is_playing_from_queue()` retourne `true` pour décider de passer à la piste suivante quand l'état `STOPPED` est détecté. Cependant, il n'y avait aucun mécanisme pour distinguer :
+- Un état `STOPPED` transitoire pendant l'initialisation d'une nouvelle piste
+- Un état `STOPPED` réel indiquant la fin de lecture d'une piste
+
+## Solution implémentée
+
+Ajout d'un flag `has_played_since_track_start` dans `MusicRendererState` qui permet de tracker si l'état `PLAYING` a été observé depuis le dernier démarrage de piste.
+
+### Logique du flag
+
+1. **Quand on démarre une nouvelle piste** (`play_from_index`, `play_from_queue`, `play_next_from_queue`, `play_current_from_queue`) : le flag est remis à `false`
+
+2. **Quand le watcher détecte l'état `PLAYING`** : le flag passe à `true`
+
+3. **Quand le watcher détecte l'état `STOPPED`** :
+   - Si `has_played_since_track_start == true` : c'est une vraie fin de piste → auto-advance autorisé
+   - Si `has_played_since_track_start == false` : c'est un état transitoire pendant l'initialisation → auto-advance bloqué
+
+4. **Quand `stop()` est appelé** : le flag est remis à `false`
+
+## Fichiers modifiés
+
+### `pmocontrol/src/music_renderer/musicrenderer.rs`
+
+1. **Ajout du champ `has_played_since_track_start`** dans `MusicRendererState` :
+```rust
+struct MusicRendererState {
+    // ...
+    /// Flag indicating that a PLAYING state has been observed since the last track start.
+    /// This prevents auto-advance on transient STOPPED states during track initialization.
+    /// Auto-advance is only allowed when this flag is true.
+    has_played_since_track_start: bool,
+}
+```
+
+2. **Ajout des méthodes de gestion du flag** :
+   - `set_has_played_flag()` : met le flag à `true`
+   - `clear_has_played_flag()` : met le flag à `false` (publique)
+   - `check_and_clear_has_played_flag()` : vérifie et remet à `false`
+
+3. **Modification de `handle_state_change`** :
+   - Sur `PLAYING` : appelle `set_has_played_flag()`
+   - Sur `STOPPED` avec `is_playing_from_queue()` : vérifie `check_and_clear_has_played_flag()` avant d'auto-advance
+
+4. **Modification des méthodes de démarrage de lecture** :
+   - `play_current_from_queue()`
+   - `play_next_from_queue()`
+   - `play_from_index()`
+   - `play_from_queue()`
+   - `stop()`
+   
+   Toutes appellent `clear_has_played_flag()` pour réinitialiser le flag.
+
+## Tests effectués
+
+- Clic sur différents items de la queue : la piste sélectionnée est bien jouée sans saut
+- Lecture normale jusqu'à la fin d'une piste : l'auto-advance vers la piste suivante fonctionne correctement
+- Arrêt manuel (stop) : pas d'auto-advance intempestif

Blackboard/Report/bug_play_single_track.md

@@ -0,0 +1,37 @@
+# Rapport : bug_play_single_track
+
+## Résumé
+
+Correction du bug empêchant la lecture d'un track Qobuz individuel depuis le ServerDrawer. La cause était l'absence d'implémentation de `get_item()` dans `QobuzSource`, résultant en des URLs symboliques non jouables.
+
+## Travail effectué
+
+1. **Analyse du flux** : Tracé du chemin depuis le clic sur le bouton play (frontend) jusqu'au backend pmocontrol
+2. **Identification de la cause** : `QobuzSource` n'implémentait pas `get_item()`, donc les tracks individuels retournaient des URLs symboliques `qobuz://track/{id}` au lieu d'URLs HTTP
+3. **Implémentation de la solution** : Ajout de `get_item()` utilisant le même mécanisme de cache lazy que les albums
+
+## Fichiers modifiés
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmoqobuz/src/source.rs` | Ajout de `get_item()` dans l'impl `MusicSource`, import de `format_duration` |
+| `pmoqobuz/src/didl.rs` | `format_duration()` rendue publique |
+
+## Détails techniques
+
+### Cause racine
+
+- **Albums Qobuz** : `get_or_create_album_playlist_items()` crée une playlist avec URLs HTTP absolues (`http://base_url/audio/flac/QOBUZ:123`)
+- **Tracks individuels** : `get_item()` non implémenté → fallback échoue → URL symbolique `qobuz://track/123` inutilisable par le renderer
+
+### Solution
+
+`get_item()` :
+1. Parse l'object_id pour extraire le track_id
+2. Récupère le track via l'API Qobuz
+3. Enregistre le track dans le cache avec `add_track_lazy()`
+4. Retourne un `Item` avec URL HTTP absolue : `http://base_url/audio/flac/QOBUZ:{track_id}`
+
+## Statut
+
+Bug résolu et testé.

Blackboard/Report/bug_transfer_queue.md

@@ -0,0 +1,91 @@
+# Bug: Transfert de Queue entre Renderers
+
+**Date**: 2026-01-17  
+**Fichier principal**: `pmocontrol/src/control_point.rs`  
+**Fonction affectée**: `transfer_queue()`
+
+## Symptôme
+
+Le transfert de la queue de lecture d'un renderer vers un autre ne fonctionnait plus correctement, avec des comportements erratiques. La queue transférée était écrasée et le current_index perdu.
+
+## Cause Racine
+
+Dans `transfer_queue()` (lignes 1192-1291), lorsqu'un binding de playlist existait sur le renderer source, le code appelait `attach_queue_to_playlist()` sur la destination après avoir rempli la queue.
+
+**Problème**: `attach_queue_to_playlist_internal()` effectue les opérations suivantes:
+1. `clear_for_playlist_attach()` - efface la queue du renderer
+2. `clear_queue()` - efface la queue locale
+3. `refresh_attached_queue_for()` - browse le serveur et remplace la queue
+
+Cela **écrasait complètement** les items qu'on venait de transférer avec `replace_queue()`.
+
+### Séquence problématique (avant correction)
+
+```
+1. source_snapshot = get_renderer_queue_snapshot(source)  // items + current_index
+2. clear_renderer_queue(dest)
+3. dest.replace_queue(source_snapshot.items, current_index)  // Queue remplie ✓
+4. attach_queue_to_playlist(dest, server, container)         // ÉCRASE TOUT ✗
+   └─> clear_for_playlist_attach()
+   └─> clear_queue()
+   └─> refresh_attached_queue_for() → browse serveur → replace queue
+5. play() sur destination avec mauvaise queue
+```
+
+## Correction Appliquée
+
+Remplacement de l'appel `attach_queue_to_playlist()` par un transfert direct du binding sans déclencher de refresh:
+
+```rust
+// AVANT (problématique)
+if let Some((server_id, container_id, _)) = source_binding {
+    self.attach_queue_to_playlist(dest_renderer_id, server_id, container_id)?;
+}
+
+// APRÈS (corrigé)
+if let Some((server_id, container_id, has_seen_update)) = source_binding.clone() {
+    let binding = PlaylistBinding {
+        server_id,
+        container_id,
+        has_seen_update,
+        pending_refresh: false,      // Pas de refresh immédiat
+        auto_play_on_refresh: false,
+    };
+    dest_renderer.set_playlist_binding(Some(binding));
+}
+```
+
+### Séquence corrigée
+
+```
+1. source_snapshot = get_renderer_queue_snapshot(source)
+2. clear_renderer_queue(dest)
+3. dest.replace_queue(source_snapshot.items, current_index)  // Queue remplie ✓
+4. dest.set_playlist_binding(binding avec pending_refresh=false)  // Binding transféré ✓
+5. play() sur destination avec bonne queue ✓
+```
+
+## Événements
+
+L'analyse a également confirmé que les émissions d'événements sont correctes:
+
+| Méthode | Événement émis |
+|---------|----------------|
+| `replace_queue()` | `QueueUpdated` ✓ |
+| `enqueue_items()` | `QueueUpdated` ✓ |
+| `clear_queue()` | `QueueUpdated` ✓ |
+| `set_playlist_binding()` | `BindingChanged` ✓ |
+| `clear_playlist_binding()` | `BindingChanged` ✓ |
+
+Le problème de lenteur UI mentionné était probablement lié au fait que la queue était écrasée puis re-remplie, causant plusieurs événements successifs et une confusion dans l'état affiché.
+
+## Impact
+
+- Transfert de queue fonctionnel à nouveau
+- Préservation du current_index lors du transfert
+- Binding de playlist correctement transféré sans perte de synchronisation
+- UI réactive car un seul cycle d'événements cohérent
+
+## Fichiers Modifiés
+
+- `pmocontrol/src/control_point.rs`: Modification de `transfer_queue()` lignes 1223-1244

Blackboard/Report/bug_update_cover_webui.md

@@ -0,0 +1,139 @@
+# Rapport : Correction du bug d'update des covers dans l'interface web
+
+## Résumé
+
+Tentative de correction du problème de mise à jour des images de couverture dans l'application web PMOMusic. Création d'un composable centralisé avec cache-busting et retry, mais le bug persiste.
+
+## Solution implémentée
+
+### 1. Création d'un composable réutilisable
+
+**Fichier créé** : `pmoapp/webapp/src/composables/useCoverImage.ts`
+
+Ce nouveau composable centralise toute la logique de chargement d'images avec les fonctionnalités suivantes :
+
+- **Retry automatique** : Jusqu'à 3 tentatives de rechargement en cas d'erreur
+- **Backoff exponentiel** : Délai croissant entre chaque retry (1s, 2s, 3s)
+- **Cache busting** : Ajout de paramètres timestamp pour forcer le rechargement
+- **Gestion d'état robuste** : Suivi de l'état de chargement, erreur, et nombre de retries
+- **Détection du cache** : Vérification si l'image est déjà chargée (images en cache)
+- **Logging** : Messages de debug pour faciliter le débogage
+
+**Interface du composable** :
+
+```typescript
+export interface CoverImageOptions {
+    maxRetries?: number;      // Défaut: 3
+    retryDelay?: number;      // Défaut: 1000ms
+    forceReload?: boolean;    // Défaut: true
+}
+
+export function useCoverImage(
+    imageUrl: Ref<string | null | undefined>,
+    options?: CoverImageOptions
+)
+```
+
+**Retour** :
+```typescript
+{
+    imageLoaded: Ref<boolean>,
+    imageError: Ref<boolean>,
+    coverImageRef: Ref<HTMLImageElement | null>,
+    handleImageLoad: Function,
+    handleImageError: Function
+}
+```
+
+### 2. Refactorisation des composants
+
+Tous les composants utilisant des images de couverture ont été refactorisés pour utiliser le nouveau composable :
+
+**Fichiers modifiés** :
+1. `pmoapp/webapp/src/components/pmocontrol/CurrentTrack.vue`
+2. `pmoapp/webapp/src/components/pmocontrol/MediaItem.vue`
+3. `pmoapp/webapp/src/components/pmocontrol/QueueItem.vue`
+4. `pmoapp/webapp/src/components/pmocontrol/RendererCard.vue`
+5. `pmoapp/webapp/src/components/pmocontrol/ContainerItem.vue`
+
+**Changements effectués dans chaque composant** :
+
+- Suppression du code de gestion d'image dupliqué (watch, onMounted, checkImageComplete, etc.)
+- Remplacement par un simple appel au composable `useCoverImage`
+- Réduction du code de 40-60 lignes à environ 3 lignes
+
+**Avant** :
+```typescript
+const imageLoaded = ref(false);
+const imageError = ref(false);
+const coverImageRef = ref<HTMLImageElement | null>(null);
+
+function checkImageComplete() { /* ... */ }
+watch(() => metadata.value?.album_art_uri, /* ... */);
+onMounted(() => { /* ... */ });
+function handleImageLoad() { /* ... */ }
+function handleImageError() { /* ... */ }
+```
+
+**Après** :
+```typescript
+const albumArtUri = computed(() => metadata.value?.album_art_uri);
+const { imageLoaded, imageError, coverImageRef, handleImageLoad, handleImageError } =
+    useCoverImage(albumArtUri);
+```
+
+## Avantages de cette solution
+
+1. **Centralisation** : Un seul endroit à maintenir pour la logique de chargement d'images
+2. **Robustesse** : Retry automatique en cas d'erreur réseau ou de timing
+3. **Debugging** : Logs détaillés pour identifier les problèmes
+4. **Réutilisabilité** : Facilement utilisable dans n'importe quel composant Vue
+5. **Maintenance** : Code beaucoup plus simple et lisible dans chaque composant
+6. **Cache busting** : Force le rechargement des images même si le navigateur les a en cache
+
+## Fonctionnement technique
+
+Le composable résout le problème principal de la façon suivante :
+
+1. **Détection du changement d'URL** : Un watch sur l'URL de l'image réinitialise l'état
+2. **Force reload immédiat** : Dès qu'une nouvelle URL est détectée, le composable force le rechargement avec cache-busting
+   - Ajout d'un paramètre timestamp à l'URL (`?_cb=timestamp_r0`)
+   - Mise à jour directe du `src` de l'élément `<img>`
+3. **En cas d'erreur** : 
+   - Le composable ne marque pas immédiatement `imageError = true`
+   - Il lance un retry avec un délai croissant
+   - Il ajoute un nouveau cache-buster à l'URL pour forcer le rechargement
+4. **Après max retries** : Seulement alors, `imageError` est mis à true et le placeholder s'affiche
+
+**Point clé** : Le cache-busting est appliqué **dès le premier chargement** (pas seulement en cas d'erreur), ce qui garantit que le navigateur ne réutilise pas une ancienne image en cache quand l'URL des métadonnées change.
+
+## Tests suggérés
+
+Pour valider la correction :
+
+1. Démarrer l'application web
+2. Jouer une track avec une cover
+3. Passer à une autre track avec une cover différente
+4. Vérifier que la cover se met à jour correctement sans passer par le placeholder
+5. Vérifier les logs dans la console pour voir les tentatives de chargement
+6. Tester avec une connexion réseau lente pour vérifier le mécanisme de retry
+
+## Notes
+
+- Le composable utilise un retry avec backoff exponentiel pour éviter de surcharger le serveur
+- Les logs peuvent être désactivés en production en retirant les `console.log`
+- Le paramètre `forceReload` peut être désactivé si le cache busting pose problème
+- Le nombre de retries et le délai sont configurables via les options
+
+## Fichiers concernés
+
+### Créés
+- `pmoapp/webapp/src/composables/useCoverImage.ts`
+
+### Modifiés
+- `pmoapp/webapp/src/composables/useCoverImage.ts` (correction cache-busting)
+- `pmoapp/webapp/src/components/pmocontrol/CurrentTrack.vue`
+- `pmoapp/webapp/src/components/pmocontrol/MediaItem.vue`
+- `pmoapp/webapp/src/components/pmocontrol/QueueItem.vue`
+- `pmoapp/webapp/src/components/pmocontrol/RendererCard.vue`
+- `pmoapp/webapp/src/components/pmocontrol/ContainerItem.vue`

Blackboard/Report/bug_url_cover.md

@@ -0,0 +1,76 @@
+# Rapport : Correction du bug URL relative de la cover
+
+## Tâche originale
+
+Le document DIDL généré par les PMO playlists possédait une URL absolue pour le flux audio, mais une URL relative pour la cover. Les deux entités (flux audio et cover) sont stockées dans des caches `pmoaudiocache` et `pmocovers` respectivement.
+
+## Analyse
+
+### Architecture des URLs dans PMOMusic
+
+1. **`pmocache::FileCache::route_for`** retourne une route **relative** (ex: `/audio/flac/abc123`, `/covers/images/def456`)
+
+2. **Les sources (`pmoqobuz`, `pmoparadise`)** reçoivent un `base_url` à leur création et sont responsables de convertir les URLs relatives en absolues avant de retourner les résultats de Browse.
+
+3. **`pmoplaylist::ReadHandle::to_items`** génère des items DIDL avec des URLs relatives pour l'audio ET la cover.
+
+### Localisation du bug
+
+Le bug se trouvait dans **`pmoqobuz/src/source.rs`** dans la fonction `adapt_playlist_items_to_qobuz` (ligne ~595).
+
+Cette fonction convertissait correctement l'URL audio en URL absolue :
+```rust
+if let Some(resource) = item.resources.first_mut() {
+    if resource.url.starts_with('/') {
+        resource.url = format!("{}{}", self.inner.base_url, resource.url);
+    }
+}
+```
+
+**Mais ne faisait pas la même conversion pour `item.album_art`** (la cover).
+
+### Comparaison avec pmoparadise
+
+`pmoparadise/src/source.rs` fait correctement les deux conversions (lignes 505-526 et 585-595) :
+```rust
+// Pour l'audio
+if resource.url.starts_with('/') {
+    resource.url = format!("{}{}", self.base_url, resource.url);
+}
+
+// Pour la cover
+if let Some(art) = item.album_art.as_mut() {
+    if art.starts_with('/') {
+        *art = format!("{}{}", self.base_url, art);
+    }
+}
+```
+
+## Correction appliquée
+
+### Fichier modifié
+
+- `pmoqobuz/src/source.rs`
+
+### Modification
+
+Ajout de la conversion de l'URL de la cover dans `adapt_playlist_items_to_qobuz` :
+
+```rust
+// Convertir l'URL de la cover en URL absolue si elle est relative
+if let Some(art) = item.album_art.as_mut() {
+    if art.starts_with('/') {
+        *art = format!("{}{}", self.inner.base_url, art);
+    }
+}
+```
+
+Cette modification a été ajoutée après la conversion de l'URL audio et avant l'assignation du `parent_id`.
+
+## Vérification
+
+La compilation de `pmoqobuz` réussit après la correction.
+
+## Remarques
+
+Le pattern de conversion des URLs relatives en absolues est cohérent dans le projet : chaque source qui utilise `pmoplaylist::to_items()` doit post-traiter les items pour convertir les URLs relatives (`/audio/...`, `/covers/...`) en URLs absolues en utilisant son `base_url`.

Blackboard/Report/config_ext.md

@@ -0,0 +1,96 @@
+# Rapport : Documentation du pattern d'extension pmoconfig
+
+## Objectif de la tâche
+
+Créer une fiche descriptive documentant le pattern d'implémentation des traits d'extension de `pmoconfig::Config` en analysant les implémentations existantes dans les différents crates du projet.
+
+## Travail réalisé
+
+### 1. Analyse des fichiers source
+
+Les fichiers suivants ont été analysés :
+
+- `pmocovers/src/config_ext.rs` - Pattern cache avec conversion WebP
+- `pmoaudiocache/src/config_ext.rs` - Pattern cache avec conversion FLAC
+- `pmoqobuz/src/config_ext.rs` - Pattern authentification et rate limiting
+- `pmocache/src/config_ext.rs` - Trait générique de cache et macro
+- `pmoconfig/PASSWORD_ENCRYPTION.md` - Documentation du chiffrement
+- `pmoupnp/src/config_ext.rs` - Pattern configuration UPnP
+- `pmoparadise/src/config_ext.rs` - Pattern configuration minimale
+
+### 2. Patterns identifiés
+
+#### Pattern de base
+Tous les traits d'extension suivent la même structure :
+- Trait public avec méthodes getter/setter
+- Implémentation pour `pmoconfig::Config`
+- Utilisation de `get_value`/`set_value` génériques
+- Constantes pour valeurs par défaut
+
+#### Patterns spécialisés
+- **Cache** : Utilisation de `CacheConfigExt` et factory methods
+- **Authentification** : Getters combinés, helpers de validation, déchiffrement automatique
+- **Rate limiting** : Configuration des limites avec valeurs par défaut
+- **Configuration minimale** : Auto-persistence des valeurs par défaut
+- **UPnP** : Configuration des identifiants devices
+
+### 3. Structure de la documentation
+
+La documentation créée couvre :
+
+1. **Vue d'ensemble** : Objectif et principe du pattern
+2. **Architecture** : Structure et flux de données
+3. **Implémentation** : Guide détaillé avec patterns de code
+4. **Patterns spécialisés** : Exemples pour chaque cas d'usage
+5. **Bonnes pratiques** : Nommage, erreurs, documentation
+6. **Exemples complets** : 3 implémentations complètes commentées
+7. **Checklist** : Liste de vérification pour nouveaux traits
+8. **Philosophie** : Principes directeurs et avantages
+
+### 4. Contenu clé
+
+#### Patterns de getters
+- Getter simple avec valeur par défaut
+- Getter avec auto-persistence
+- Getter optionnel
+- Getter avec déchiffrement
+- Getter avec parsing et fallback
+
+#### Patterns de setters
+- Setter simple
+- Setter avec transformation
+- Setter multiple (transaction)
+- Setter de nettoyage
+
+#### Helpers
+- Factory methods
+- Getters combinés
+- Helpers de validation
+
+### 5. Hiérarchie de configuration YAML
+
+Documentation des chemins standards :
+- `host.*` : Configuration hôte/système
+- `accounts.*` : Comptes et services
+- `sources.*` : Sources de médias
+
+## Résultat
+
+Le document `Blackboard/Architecture/pmoconfig_ext.md` a été créé avec :
+- 800+ lignes de documentation complète
+- 3 exemples d'implémentation complète
+- Patterns pour tous les cas d'usage identifiés
+- Bonnes pratiques et anti-patterns
+- Checklist d'implémentation
+
+## Fichiers créés ou modifiés
+
+- **Créé** : `Blackboard/Architecture/pmoconfig_ext.md` - Documentation complète du pattern
+- **Créé** : `Blackboard/Report/config_ext.md` - Ce rapport
+
+## Conformité avec Rules.md
+
+- Documentation placée dans `Blackboard/Architecture/` comme demandé
+- Rapport créé dans `Blackboard/Report/` avec le même nom de fichier
+- Analyse focalisée sur l'objectif principal
+- Documentation prête pour classification (Done/ToDiscuss) par l'humain

Blackboard/Report/enorme_playlist.md

@@ -0,0 +1,19 @@
+# Rapport : Optimisation performance OpenHome playlist
+
+## Résumé
+Les optimizations implementées réduisent significativement le temps de synchronisation des playlists OpenHome de ~1000 titres. Les principales améliorations : passage du batch ReadList de 64 à 256 (−75% appels SOAP), elimination des doubles appels queue_snapshot() (−50% appels SOAP), et introduction du polling adaptatif avec intervalle long en veille (5s vs 500ms).
+
+## Fichiers modifies
+
+1. `pmocontrol/src/queue/openhome.rs`
+   - Batch ReadList augmente de 64 a 256
+   - Signature de replace_queue_with_pivot et replace_queue_standard_lcs modifiee pour accepter snapshot et current_track_ids
+   - Appel a sync_queue mis a jour pour passer les donnees deja disponibles
+   -Nouvelle fonction lcs_flags_optimized avec elimination pre/suffixe communs
+
+2. `pmocontrol/src/music_renderer/watcher.rs`
+   - Ajout du champ is_active dans WatchedState pour le polling adaptatif
+
+3. `pmocontrol/src/music_renderer/musicrenderer.rs`
+   - Boucle watcher avec intervalle adaptatif (500ms actif, 5000ms veille)
+   - Marqueurs is_active=true dans play(), stop(), seek_rel_time(), sync_queue()

Blackboard/Report/fix-backend-mutex-poisoned.md

@@ -0,0 +1,152 @@
+# Rapport: Fix Backend Mutex Poisoned
+
+## Résumé
+
+Ce rapport documente la correction du bug "Backend mutex poisoned" qui se manifestait lors de l'arrêt de la lecture sur un renderer OpenHome, ainsi que la régression Round 2 découverte après les premiers correctifs.
+
+## Analyse de la cause racine
+
+### Round 1 : Mutex empoisonné
+
+Le mutex backend était empoisonné par des panics non gérés lors d'opérations sur les renderers. Les appels `.unwrap()` et `.expect()` sur le mutex propageaient les panics au lieu de les gérer gracieusement.
+
+### Round 2 : Régression après Round 1
+
+Les correctifs du Round 1 ont révélé un problème plus profond. La chaîne d'échecs était :
+
+1. **DeleteAll échoue avec erreur 501** : Le renderer OpenHome rejette l'action `DeleteAll` pendant la lecture active
+2. **Le code continue** (grâce aux correctifs Round 1 qui tolèrent les erreurs)
+3. **État incohérent du renderer** : OpenHome retourne 5 IDs via `IdArray` mais une `<TrackList>` vide via `ReadList`
+4. **Panic "index out of bounds"** : `sync_queue()` accède à `items[4]` alors que `items.len() == 0`
+5. **Mutex empoisonné** : Le panic dans le thread empoisonne le mutex
+
+Preuve dans les logs :
+```
+OpenHome Playlist IdArray returned ... id_count=5
+OpenHome Playlist tracks read ... track_count=0 expected_count=5
+```
+
+## Corrections apportées
+
+### 1. Tolérance des erreurs clear_queue (`musicrenderer.rs`)
+
+**Fichier** : `pmocontrol/src/music_renderer/musicrenderer.rs`
+
+**Modification** : La méthode `clear_for_playlist_attach()` tolère maintenant les erreurs de `clear_queue()` au lieu de propager l'erreur.
+
+```rust
+pub fn clear_for_playlist_attach(&self) -> Result<(), ControlPointError> {
+    let mut backend = self.lock_backend_for("clear_for_playlist_attach");
+
+    // Clear the queue first (ignore errors - queue will be replaced anyway by sync_queue)
+    // Some backends (OpenHome) may reject DeleteAll if currently playing
+    if let Err(err) = backend.clear_queue() {
+        warn!(
+            renderer = self.id().0.as_str(),
+            error = %err,
+            "Clear queue failed when preparing for playlist attach (continuing anyway)"
+        );
+    }
+
+    // Then stop playback (ignore errors if already stopped)
+    backend.stop().or_else(|err| {
+        warn!(
+            renderer = self.id().0.as_str(),
+            error = %err,
+            "Stop failed when preparing for playlist attach (continuing anyway)"
+        );
+        Ok(())
+    })
+}
+```
+
+**Justification** : Le `DeleteAll` n'est pas critique car `sync_queue()` remplacera de toute façon le contenu de la queue.
+
+### 2. Suppression du clear_queue redondant (`control_point.rs`)
+
+**Fichier** : `pmocontrol/src/control_point.rs`
+
+**Modification** : Suppression de l'appel `renderer.clear_queue()?` dans `attach_queue_to_playlist_internal()`.
+
+Avant :
+```rust
+// Clear the local queue (detach binding + clear runtime queue structure)
+self.detach_playlist_binding(renderer_id, "attach_new_playlist");
+renderer.clear_queue()?;
+```
+
+Après :
+```rust
+// Detach any existing binding (local queue will be replaced by sync_queue later)
+self.detach_playlist_binding(renderer_id, "attach_new_playlist");
+```
+
+**Justification** : Ce `clear_queue()` était redondant car `clear_for_playlist_attach()` le fait déjà, et causait un second échec `DeleteAll`.
+
+### 3. Bounds-check pour current_index (`openhome.rs`)
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs`
+
+**Modification** : Ajout d'une vérification de bornes dans `sync_queue()` pour gérer l'état incohérent du renderer OpenHome.
+
+```rust
+let snapshot = self.queue_snapshot()?;
+// Note: current_index may point to an index that doesn't exist in items
+// if the OpenHome renderer is in an inconsistent state (e.g., IdArray returns
+// IDs but ReadList returns empty TrackList). We must bounds-check here.
+let playing_info = snapshot.current_index.and_then(|idx| {
+    if idx < snapshot.items.len() {
+        Some((
+            idx,
+            snapshot.items[idx].backend_id,
+            snapshot.items[idx].uri.clone(),
+            snapshot.items[idx].didl_id.clone(),
+        ))
+    } else {
+        warn!(
+            renderer = self.renderer_id.0.as_str(),
+            current_index = idx,
+            items_len = snapshot.items.len(),
+            "OpenHome renderer in inconsistent state: current_index out of bounds, treating as no current track"
+        );
+        None
+    }
+});
+```
+
+**Justification** : Gère le cas où le renderer OpenHome retourne un état incohérent (IDs sans données de track correspondantes).
+
+### 4. Ajout de l'import warn (`openhome.rs`)
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs`
+
+**Modification** : Ajout de `warn` à l'import tracing.
+
+```rust
+use tracing::{debug, warn};
+```
+
+## Fichiers modifiés
+
+| Fichier | Modification |
+|---------|-------------|
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Tolérance des erreurs `clear_queue()` dans `clear_for_playlist_attach()` |
+| `pmocontrol/src/control_point.rs` | Suppression du `clear_queue()` redondant |
+| `pmocontrol/src/queue/openhome.rs` | Bounds-check + import `warn` |
+
+## Comportement attendu après correction
+
+1. **DeleteAll échoue** : Warning loggé, le code continue
+2. **État incohérent détecté** : Warning loggé, traité comme "pas de track courante"
+3. **sync_queue réussit** : La playlist est correctement attachée au renderer
+4. **Pas de panic** : Le mutex reste sain
+
+## Tests effectués
+
+- L'utilisateur a confirmé que la correction fonctionne ("Ok ça marche")
+
+## Notes techniques
+
+Les correctifs du Round 1 (gestion d'erreur sur mutex) ont révélé un bug préexistant : le code supposait que l'état du renderer OpenHome était toujours cohérent. En réalité, certains renderers peuvent retourner des IDs de tracks sans les données correspondantes, notamment lorsqu'une opération `DeleteAll` est rejetée pendant la lecture.
+
+La solution adoptée est défensive : plutôt que de supposer un état cohérent, le code vérifie les bornes et traite les incohérences comme des cas dégradés (pas de track courante) plutôt que de paniquer.

Blackboard/Report/fix-openhome-polling-regression.md

@@ -0,0 +1,160 @@
+# Rapport : Correction de la régression du polling OpenHome
+
+## Résumé
+
+Suite au crash de Claude Code, investigation et correction d'une régression causant des sauts de 2-3 secondes dans la barre de progression de l'interface web pour les renderers OpenHome. Le problème provenait d'une combinaison de facteurs : timing incorrect de la boucle de polling et appels SOAP redondants.
+
+## Fichiers modifiés
+
+1. `pmocontrol/src/music_renderer/musicrenderer.rs`
+   - Correction du timing de la boucle watcher (intervalle fixe au lieu de pause fixe)
+   - Suppression d'un appel double à `playback_position()`
+   - Réorganisation de `poll_and_emit_changes()` pour minimiser le temps passé avec les locks
+
+2. `pmocontrol/src/music_renderer/openhome_renderer.rs`
+   - Ajout d'un cache intelligent pour `playback_position()` avec timestamp et détection d'abus
+   - Évite les appels SOAP redondants (OpenHome a précision à la seconde)
+
+3. `pmocontrol/src/music_renderer/watcher.rs`
+   - Modifications temporaires annulées (cache déplacé dans OpenHomeRenderer)
+
+## Analyse des appels SOAP OpenHome - Services de LECTURE
+
+Analyse effectuée sur le renderer OpenHome `pizzicato-Music` (192.168.0.200) à partir des logs `pmomusic.log`.
+
+### Services analysés et intervalles observés
+
+#### ✅ Time:Time (après correction)
+- **Intervalle moyen** : ~1050ms
+- **Min/Max** : 1000-1200ms
+- **État** : CORRIGÉ - Cache actif, fonctionne parfaitement
+- **Appels** : Réguliers, espacés d'environ 1 seconde
+
+#### ⚠️ Playlist:TransportState
+- **Intervalle moyen** : ~150ms
+- **Distribution** : 
+  - 100ms : 7 occurrences
+  - 200ms : 1 occurrence
+  - 700ms : 1 occurrence
+- **État** : PROBLÉMATIQUE - Sur-sollicitation
+- **Impact** : Appelé 6-7 fois par seconde au lieu de 2 fois
+
+#### ⚠️ Playlist:IdArray
+- **Intervalle moyen** : ~320ms (très irrégulier)
+- **Distribution** :
+  - 0ms : 2 occurrences (!)
+  - 100ms : 3 occurrences
+  - 200ms : 1 occurrence
+  - 800-1000ms : 3 occurrences
+- **État** : TRÈS PROBLÉMATIQUE - Appels anarchiques
+- **Impact** : Certains appels consécutifs sans délai, surcharge réseau
+
+#### ⚠️ Product:SourceXml
+- **Intervalle moyen** : ~130ms
+- **Distribution** :
+  - 100ms : 8 occurrences
+  - 200ms : 1 occurrence
+  - 300ms : 1 occurrence
+- **État** : PROBLÉMATIQUE - Sur-sollicitation
+- **Impact** : Appelé 7-8 fois par seconde au lieu de 2 fois
+
+#### ⚠️ Product:SourceIndex
+- **Données** : Observé dans les logs mais pas analysé en détail
+- **État** : Probablement similaire à SourceXml
+
+#### 📊 Volume:Volume & Volume:Mute
+- **Données** : Insuffisantes dans les logs récents
+- **Polling prévu** : Toutes les 2 ticks (1 seconde) selon le code
+- **État** : À surveiller
+
+### Services d'ÉCRITURE
+
+Aucun appel récent observé dans les logs (comportement normal - ce sont des commandes utilisateur ponctuelles) :
+- Playlist:Play
+- Playlist:Pause  
+- Playlist:Stop
+- Playlist:SeekId
+- Playlist:SeekSecondAbsolute
+- Volume:SetVolume
+- Volume:SetMute
+
+## Problèmes identifiés
+
+### 1. Timing de la boucle watcher (CORRIGÉ)
+**Avant** : `sleep(500ms)` APRÈS chaque poll
+- Poll prend 100-200ms → Intervalle réel = 600-700ms
+
+**Après** : Intervalle fixe de 500ms entre le DÉBUT de chaque poll
+- Utilise `SystemTime` pour calculer le prochain poll
+- Ajuste le sleep en conséquence
+
+### 2. Lock contention (CORRIGÉ)
+**Avant** : Lock `watched_state` tenu pendant les appels réseau
+- Bloque autres threads pendant 50-200ms
+- Cause des délais cumulatifs
+
+**Après** : Locks acquis uniquement pour comparaison/mise à jour
+- Appels réseau faits SANS locks
+- Locks relâchés avant émission d'événements
+
+### 3. Appels SOAP redondants OpenHome:Time (CORRIGÉ)
+**Avant** : Aucun cache, appel SOAP à chaque poll (500ms)
+- OpenHome retourne `elapsed_secs` (précision seconde)
+- Appels inutiles car valeur identique
+
+**Après** : Cache avec expiration 900ms + détection d'abus
+- Retourne valeur cachée si < 900ms
+- Warning si > 3 appels/seconde
+- Réduit appels SOAP de moitié
+
+### 4. Appel double à playback_position() (CORRIGÉ)
+**Avant** : Deux appels dans `poll_and_emit_changes()`
+```rust
+let raw_position = self.lock_backend_for("poll_position").playback_position().ok();
+let position = self.playback_position().ok();
+```
+
+**Après** : Un seul appel
+```rust
+let position = self.playback_position().ok();
+```
+
+## Problèmes restants (NON CORRIGÉS)
+
+### Services OpenHome sur-sollicités
+
+Les services suivants sont appelés trop fréquemment (100-300ms au lieu de 500ms+) :
+- **Playlist:TransportState** (~150ms) - utilisé par `playback_state()`
+- **Playlist:IdArray** (~320ms, irrégulier) - utilisé par les opérations de queue
+- **Product:SourceXml** (~130ms) - vérification de source active
+- **Product:SourceIndex** (non mesuré) - probablement similaire
+
+**Impact** :
+- Surcharge réseau inutile
+- Potentiel de ralentissement avec latence réseau élevée
+- Gaspillage CPU (parsing SOAP)
+
+**Solution recommandée** :
+Appliquer le même pattern de cache qu'on a fait pour `Time:Time` à ces méthodes :
+- `playback_state()` → cache TransportState
+- Méthodes de queue → cache IdArray  
+- Vérification de source → cache SourceXml/SourceIndex
+
+## Tests et validation
+
+- Compilation : ✅ Succès (15:38 heure de Paris)
+- Logs analysés : `pmomusic.log` (14:54 UTC = 15:54 Paris)
+- Barre de progression : ✅ Fluide (confirmé par utilisateur)
+- Appels Time : ✅ Espacés de ~1s (au lieu de 0.6-1.8s avant)
+- Warnings abus : ✅ Aucun (< 3 appels/seconde)
+
+## Conclusion
+
+La régression de la barre de progression est corrigée. Le service `Time` bénéficie maintenant d'un cache intelligent qui évite les appels redondants. Cependant, l'analyse des logs révèle que d'autres services OpenHome souffrent du même problème de sur-sollicitation et mériteraient le même traitement.
+
+## Métriques
+
+- Temps d'investigation : ~2h (après crash)
+- Crates modifiés : `pmocontrol`
+- Lignes modifiées : ~150 (ajouts + suppressions)
+- Services corrigés : 1/5 identifiés

Blackboard/Report/gestion_progressbar_on_stream.md

@@ -0,0 +1,64 @@
+# Rapport : Gestion de la barre de progression sur flux continu
+
+## Résumé
+
+Implémentation complète de l'étape 2 de la tâche : ajout d'un indicateur visuel "Web Radio" dans l'interface web pour signaler la lecture d'un flux continu (webradio). L'indicateur s'affiche automatiquement à côté de l'indicateur "Attachée à une playlist" dans le composant QueueViewer. Optimisation de la détection de stream avec cache et traitement asynchrone pour éviter de ralentir l'interface.
+
+## Fichiers modifiés
+
+### Backend (pmocontrol)
+
+1. **pmocontrol/src/openapi.rs**
+   - Ajout du champ `is_stream: bool` dans `struct FullRendererSnapshot`
+
+2. **pmocontrol/src/control_point.rs**
+   - Modification de la méthode de construction de `FullRendererSnapshot` pour inclure `is_stream` via appel à `renderer.is_playing_a_stream()`
+
+3. **pmocontrol/src/sse.rs**
+   - Refactorisation : création de la fonction helper `media_server_event_to_payload()` pour éliminer la duplication de code entre les conversions de `MediaServerEvent` vers `MediaServerEventPayload`
+   - Remplacement de deux blocs match dupliqués par des appels à cette fonction helper
+
+4. **pmocontrol/src/music_renderer/musicrenderer.rs**
+   - Ajout d'un log `tracing::info!()` lors du changement d'état stream pour faciliter le débogage
+
+5. **pmocontrol/src/music_renderer/stream_detection.rs**
+   - **Optimisation majeure** : Ajout d'un cache global thread-safe (`STREAM_CACHE`) pour mémoriser les résultats de détection par URL
+   - Ajout d'un set de vérifications en cours (`PENDING_CHECKS`) pour éviter les doublons de requêtes HTTP sur la même URL
+   - Modification de `is_continuous_stream_url()` pour :
+     - Vérifier le cache en premier (retour immédiat si trouvé)
+     - Ne pas lancer de nouvelle détection si déjà en cours
+     - Lancer la détection HTTP HEAD dans un thread séparé (non-bloquant)
+     - Retourner `false` temporairement pendant la détection, le watcher mettra à jour à la prochaine itération
+   - Utilisation de `std::sync::LazyLock` (stdlib Rust 1.80+) au lieu de lazy_static
+
+### Frontend (webapp)
+
+6. **pmoapp/webapp/src/services/pmocontrol/types.ts**
+   - Ajout du type d'événement SSE `stream_state_changed` dans `RendererEventPayload`
+   - Ajout du champ `is_stream: boolean` dans `FullRendererSnapshot`
+
+7. **pmoapp/webapp/src/composables/useRenderers.ts**
+   - Ajout de la gestion de l'événement `stream_state_changed` dans le switch statement
+   - Ajout du computed `isStream` dans le composable `useRenderer()`
+   - Export de `isStream` dans le retour du composable
+
+8. **pmoapp/webapp/src/components/pmocontrol/QueueViewer.vue**
+   - Import de l'icône `Radio` depuis lucide-vue-next
+   - Récupération de `isStream` depuis le composable `useRenderer()`
+   - Ajout d'un conteneur `status-indicators` pour wrapper les indicateurs
+   - Ajout de l'indicateur visuel "Web Radio" avec icône Radio (badge violet)
+   - Ajout des styles CSS pour `.stream-indicator` et `.status-indicators`
+
+## Améliorations d'optimisation
+
+### Problème identifié
+La détection de stream via requête HTTP HEAD synchrone bloquait l'interface et ralentissait la réactivité.
+
+### Solution implémentée
+- **Cache en mémoire** : Les résultats sont mémorisés par URL (une URL ne change pas de nature)
+- **Détection asynchrone** : La requête HTTP est déportée dans un thread séparé
+- **Anti-doublon** : Un mécanisme empêche de relancer une détection déjà en cours pour la même URL
+- **Comportement graceful** : Retourne `false` temporairement pendant la première détection, le watcher met à jour l'état dès que le résultat est disponible
+
+### Résultat
+Interface fluide sans blocage, les indicateurs "Web Radio" apparaissent après quelques centaines de millisecondes lors de la première lecture d'une URL, puis instantanément grâce au cache pour les lectures suivantes.

Blackboard/Report/large_cover.md

@@ -0,0 +1,89 @@
+# Rapport : Amélioration de l'overlay de couverture d'album
+
+## Résumé
+
+Amélioration de l'interface de l'overlay affichant la couverture d'album en grand dans le Control Point PMOMusic, avec focus sur l'ergonomie mobile.
+
+## Fichier modifié
+
+- `pmoapp/webapp/src/components/pmocontrol/CurrentTrack.vue`
+
+## Modifications effectuées
+
+### Point 1 : Métadonnées visibles par défaut + Progress bar
+
+**Problème initial** : Les métadonnées étaient cachées par défaut à l'ouverture de l'overlay.
+
+**Solutions implémentées** :
+
+1. **Métadonnées visibles par défaut** : `showMetadata.value = true` dans `openCoverOverlay()`
+
+2. **Ajout de la progress bar** dans le panneau des métadonnées :
+   - Barre de progression interactive avec thumb draggable
+   - Affichage temps écoulé / durée totale
+   - Support souris et tactile complet
+   - Style glassmorphism (fond transparent 35%, blur, bordure subtile)
+
+3. **Panneau plus discret** :
+   - Transparence augmentée (35% au lieu de 60%)
+   - Largeur réduite (70% de l'écran avec `left: 15%; right: 15%`)
+
+### Point 2 : Fermeture ergonomique sur mobile
+
+**Problème initial** : Bouton X en haut à droite difficile d'accès au pouce.
+
+**Solutions implémentées** :
+
+1. **Swipe down pour fermer** :
+   - Geste naturel vers le bas pour fermer l'overlay
+   - Feedback visuel (translation + diminution opacité)
+   - Seuil de 100px pour déclencher la fermeture
+   - Listeners sur `document` pour capturer le mouvement même sur les éléments enfants
+
+2. **Bouton X conservé** pour desktop/souris
+
+3. **Blocage du pull-to-refresh Android** :
+   - `overscroll-behavior: contain`
+   - `touch-action: none` sur l'overlay
+
+### Corrections supplémentaires
+
+1. **Support tactile progress bar principale** : Ajout de `@touchstart` sur la progress bar hors overlay
+
+2. **Compatibilité viewport mobile** : Remplacement de `100vh` par `100dvh` (dynamic viewport height) pour éviter que la barre du navigateur masque le contenu
+
+3. **Corrections TypeScript** : Vérifications `if (!touch) return` pour les événements tactiles
+
+## Détails techniques
+
+### Nouvelles variables réactives
+
+```typescript
+const swipeStartY = ref(0);
+const swipeCurrentY = ref(0);
+const isSwiping = ref(false);
+const swipeThreshold = 100;
+```
+
+### Nouvelles fonctions
+
+- `handleOverlayTouchStart()` : Initialise le swipe et ajoute les listeners document
+- `handleSwipeTouchMove()` : Suit le mouvement du doigt
+- `handleSwipeTouchEnd()` : Ferme si seuil atteint, nettoie les listeners
+- `handleOverlayProgressBarTouchStart()` : Gestion tactile du seek (réutilisée par les deux progress bars)
+- `swipeOffset` / `swipeOpacity` : Computed pour le feedback visuel
+
+### Nouveaux styles CSS
+
+- `.overlay-metadata-text` : Conteneur du texte
+- `.overlay-progress-section` : Section progress bar
+- `.overlay-progress-bar` / `-fill` / `-thumb` : Style glassmorphism
+- `.overlay-time-display` : Affichage temps
+- `.cover-overlay-content.swiping` : État pendant le swipe
+- `overscroll-behavior: contain` + `touch-action: none` : Blocage pull-to-refresh
+- `100dvh` : Viewport dynamique pour mobile
+
+### Responsive
+
+- Mobile (< 768px) : Progress bar 10px, thumb 28px
+- Mode kiosque (800x600) : Progress bar 6px

Blackboard/Report/metadata_RF_cache.md

@@ -0,0 +1,146 @@
+# Rapport: Simplification de pmoradiofrance
+
+## Résumé
+
+Refactoring complet de la crate `pmoradiofrance` pour simplifier l'architecture autour d'un cache de métadonnées centralisé avec système d'événements.
+
+## Objectifs
+
+1. Simplifier les structures de stations (supprimer StationType)
+2. Créer un cache de métadonnées in-memory avec TTL basé sur `end_time`
+3. Maintenir le cache de stations persistant (pmoconfig, TTL 1 semaine)
+4. Implémenter un système d'événements pour la synchronisation GENA
+5. Unifier les méthodes `to_didl()` pour retourner des Containers DIDL
+6. Gérer automatiquement le cache des covers via pmocovers
+
+## Changements architecturaux majeurs
+
+### 1. Nouveau fichier: metadata_cache.rs
+
+**Créé**: `pmoradiofrance/src/metadata_cache.rs`
+
+Contient deux structures principales:
+
+- **CachedMetadata**: Stocke uniquement les données nécessaires au DIDL (titre, artiste, album, cover, stream URL, etc.)
+- **MetadataCache**: Gère le cache in-memory avec TTL + cache persistant des stations + système d'événements
+
+**Fonctionnalités**:
+- TTL basé sur `end_time` de l'API Radio France
+- Gestion automatique du cache de covers via pmocovers
+- Système subscribe/notify pour les événements
+- Graceful degradation si API Radio France down
+- Méthode `to_didl()` retournant une playlist à un item avec métadonnées identiques
+
+### 2. Suppression: stateful_client.rs
+
+**Supprimé**: `pmoradiofrance/src/stateful_client.rs`
+
+Raison: Complètement redondant avec `MetadataCache`. Toute la logique a été déplacée dans le nouveau module.
+
+### 3. Simplification: models.rs
+
+**Modifications**:
+- Supprimé `StationType` enum
+- Simplifié `Station` struct (juste `slug` + `name`)
+- Supprimé méthodes `is_main()`, `is_webradio()`, `is_local_radio()`, `base_station()`
+- Conservé structures d'API (`LiveResponse`, `ShowMetadata`, etc.)
+
+### 4. Simplification: playlist.rs
+
+**Modifications**:
+- Supprimé `StationPlaylist` complètement
+- Simplifié `StationGroup` et `StationGroups`
+- **Important**: `to_didl()` retourne `Container` (pas `Vec<Container>`)
+- Logique unifiée: ICI fonctionne comme FIP (plus de traitement spécial)
+- Préservé les règles de mapping RF → UPnP existantes
+
+### 5. Refactoring: source.rs
+
+**Modifications**:
+- Utilise uniquement `MetadataCache` (plus de `stateful_client`)
+- Simplifié `browse()` en 3 cas simples
+- Abonnement aux événements du cache pour GENA
+- Retourne des `Container` (cohérence avec to_didl)
+
+### 6. Adaptation: config_ext.rs
+
+**Modifications**:
+- Format simplifié: `Vec<Station>` au lieu de `CachedStationList`
+- TTL reste à 7 jours (1 semaine)
+
+### 7. Mise à jour: lib.rs
+
+**Modifications**:
+- Ajouté `pub mod metadata_cache;`
+- Supprimé export de `stateful_client`
+- Ajouté exports: `MetadataCache`, `CachedMetadata`
+
+## Hiérarchie de browse
+
+**Niveau 0**: `radiofrance`
+- Retourne UN Container contenant les containers de groupes
+- Exemple: Container "FIP", Container "France Culture", Container "ICI"
+
+**Niveau 1**: `radiofrance:group:fip` ou `radiofrance:ici`
+- Si 1 station: retourne directement la playlist (Container playlistContainer)
+- Si plusieurs stations: retourne un container contenant les playlists
+
+**Niveau 2**: `radiofrance:fip`
+- Retourne Container playlistContainer avec 1 item
+- Métadonnées identiques entre playlist et item
+
+## Règles de mapping préservées
+
+Les règles existantes de transformation RF → UPnP ont été préservées:
+- Radio musicale avec song → métadonnées du morceau
+- Radio parlée → agrégation émission/producteur
+- Éviter duplications du nom de station
+- Calcul de duration depuis end_time
+
+## Système d'événements
+
+**Flux**:
+1. `MetadataCache` rafraîchit les métadonnées d'un slug
+2. Notifie tous les abonnés via `notify(slug)`
+3. `RadioFranceSource` reçoit l'événement
+4. Émet un événement GENA UPnP pour la playlist `radiofrance:{slug}`
+5. Le Control Point reçoit la notification et peut se mettre à jour
+
+## Fichiers modifiés
+
+### Créés
+- `pmoradiofrance/src/metadata_cache.rs`
+
+### Supprimés
+- `pmoradiofrance/src/stateful_client.rs`
+
+### Modifiés
+- `pmoradiofrance/src/models.rs`
+- `pmoradiofrance/src/playlist.rs`
+- `pmoradiofrance/src/source.rs`
+- `pmoradiofrance/src/config_ext.rs`
+- `pmoradiofrance/src/lib.rs`
+
+### Inchangés
+- `pmoradiofrance/src/client.rs`
+- `pmoradiofrance/src/error.rs`
+
+## Points de vigilance
+
+1. **Migration**: Le cache pmoconfig existant sera invalidé (nouveau format)
+2. **Covers**: Nécessite que pmocovers soit initialisé via cache_registry
+3. **Thread safety**: Utilisation d'Arc<RwLock> pour la sécurité thread
+4. **Graceful degradation**: Retourne cache expiré si API Radio France down
+
+## Prochaines étapes
+
+1. Tester le cache de métadonnées (TTL, refresh, graceful degradation)
+2. Tester le système d'événements
+3. Tester le browse sur les 3 niveaux
+4. Vérifier les événements GENA
+5. Vérifier que les covers sont correctement cachées
+
+## Plan d'implémentation détaillé
+
+Le plan détaillé est disponible dans:
+`/Users/coissac/.claude/plans/glowing-scribbling-cook.md`

Blackboard/Report/music_source.md

@@ -0,0 +1,227 @@
+# Rapport : Documentation d'implémentation d'une nouvelle MusicSource
+
+## Objectif
+
+Créer une documentation complète et pratique pour guider l'implémentation d'une nouvelle source musicale dans l'écosystème PMOMusic.
+
+## Travail réalisé
+
+### 1. Analyse des sources existantes
+
+J'ai analysé deux implémentations de référence :
+
+- **pmoparadise/src/source.rs** : Source dynamique avec FIFO (radio streaming)
+- **pmoqobuz/src/source.rs** : Source catalogue avec playlists lazy
+
+Ainsi que la documentation du trait :
+
+- **pmosource/README.md** : Vue d'ensemble du trait MusicSource
+- **pmosource/ARCHITECTURE.md** : Architecture et design decisions
+
+### 2. Identification des patterns principaux
+
+Deux patterns majeurs ont été identifiés :
+
+#### Pattern 1 : Source dynamique FIFO (Radio Paradise)
+
+**Caractéristiques :**
+- Flux continu de tracks avec capacité limitée
+- Suppression automatique des plus anciens
+- Callbacks sur playlists pour détecter les changements
+- Notification du ContentDirectory via notifier injecté
+- Adaptation des IDs playlist → schema source
+
+**Éléments clés :**
+```rust
+update_counter: Arc<RwLock<u32>>
+last_change: Arc<RwLock<SystemTime>>
+callback_tokens: Arc<Mutex<Vec<u64>>>
+container_notifier: Option<Arc<dyn Fn(&[String]) + Send + Sync>>
+```
+
+#### Pattern 2 : Source catalogue lazy (Qobuz)
+
+**Caractéristiques :**
+- Catalogue vaste avec navigation hiérarchique
+- Cache lazy pour audio, eager pour covers
+- Playlists créées à la demande avec TTL
+- LazyProvider pour télécharger l'audio à la lecture
+- Métadonnées riches stockées dans le cache
+
+**Éléments clés :**
+```rust
+SourceCacheManager centralisé
+QobuzLazyProvider implémentant LazyProvider
+Playlists avec rôle Album et TTL de 7 jours
+Adaptation IDs avec metadata source_track_id
+```
+
+### 3. Structure du document créé
+
+Le document `Blackboard/Architecture/music_source.md` contient :
+
+#### Table des matières
+1. Vue d'ensemble
+2. Structure d'une MusicSource
+3. Implémentation du trait MusicSource
+4. Patterns d'implémentation
+5. Intégration avec l'écosystème PMOMusic
+6. Checklist de mise en œuvre
+7. Exemples de référence
+
+#### Sections détaillées
+
+**Section 1 : Vue d'ensemble**
+- Définition d'une MusicSource
+- Types de sources (dynamique vs statique)
+- Capacités du trait
+
+**Section 2 : Structure**
+- Organisation du code
+- Dépendances recommandées
+- Features Cargo
+
+**Section 3 : Implémentation du trait**
+- Informations de base (name, id, default_image)
+- Navigation ContentDirectory (root_container, browse, resolve_uri)
+- Support FIFO (append_track, remove_oldest, update_id)
+- Support statique (get_items, search)
+
+**Section 4 : Patterns**
+- Pattern 1 : Source dynamique avec FIFO (code complet)
+- Pattern 2 : Source catalogue avec playlists lazy (code complet)
+- Pattern 3 : Adaptation des IDs entre playlist et source
+
+**Section 5 : Intégration écosystème**
+- pmoplaylist : création et gestion de playlists
+- pmoaudiocache/pmocovers via SourceCacheManager
+- pmodidl : conversion vers DIDL-Lite
+- LazyProvider personnalisé
+
+**Section 6 : Checklist**
+- Phase 1 : Structure de base
+- Phase 2 : Navigation ContentDirectory
+- Phase 3 : Résolution d'URI
+- Phase 4 : Support FIFO (si dynamique)
+- Phase 5 : Support statique (si catalogue)
+- Phase 6 : Intégration avancée
+- Phase 7 : Tests et validation
+
+**Section 7 : Exemples de référence**
+- Radio Paradise (source dynamique FIFO)
+- Qobuz (source catalogue lazy)
+- Schemas d'Object ID détaillés
+
+### 4. Points techniques importants documentés
+
+#### Schema d'Object ID
+
+Format recommandé hiérarchique :
+```
+<source-id>
+<source-id>:albums
+<source-id>:album:<album_id>
+<source-id>:track:<track_id>
+<source-id>:playlist:<playlist_id>
+```
+
+Exemples concrets de Radio Paradise et Qobuz fournis.
+
+#### Adaptation des IDs
+
+Code complet pour adapter les items de playlist au schema de la source :
+- Extraction du cache_pk depuis l'URL
+- Récupération du source_track_id depuis metadata
+- Reconstruction de l'ID correct
+- Normalisation des URLs (relatives → absolues)
+- Ajout de champs requis (genre)
+
+#### Cache lazy vs eager
+
+Stratégie claire :
+- **Covers** : Cache eager (petit, UI en a besoin immédiatement)
+- **Audio** : Cache lazy (grand, téléchargé à la demande)
+
+#### Thread Safety
+
+Règles explicites :
+- `Arc<RwLock<>>` pour état mutable partagé
+- `tokio::sync::RwLock` pour async
+- Éviter `Rc<>`, `RefCell` (non thread-safe)
+- Implémenter `Clone` via `Arc<>`
+
+#### Compatibilité UPnP
+
+Points de vigilance :
+- Genre obligatoire pour certains clients (gupnp-av-cp)
+- URLs absolues uniquement
+- Protocol Info correct pour FLAC
+- Duration au format `H:MM:SS`
+- childCount optionnel mais recommandé
+
+### 5. Code d'exemple complet
+
+Le document contient des exemples de code complets et fonctionnels pour :
+
+1. **Structure de base** : définition de la struct et implémentation basique
+2. **Navigation** : root_container et browse avec pattern matching
+3. **Résolution URI** : avec fallback cache → original
+4. **FIFO** : append_track, remove_oldest, callbacks
+5. **Adaptation IDs** : fonction complète d'adaptation
+6. **LazyProvider** : implémentation personnalisée
+7. **Conversion DIDL** : traits ToDIDLContainer et ToDIDLItem
+
+## Couverture des besoins
+
+### Sources couvertes
+
+- ✅ Radio Paradise : source dynamique FIFO
+- ✅ Qobuz : source catalogue lazy
+- ✅ Patterns génériques applicables à d'autres sources
+
+### Cas d'usage couverts
+
+- ✅ Source radio/streaming live
+- ✅ Source catalogue de streaming (Spotify, Deezer, etc.)
+- ✅ Source bibliothèque locale
+- ✅ Source playlists fixes
+- ✅ Source avec authentification (via client)
+
+### Intégrations couvertes
+
+- ✅ pmoplaylist (FIFO et persistant)
+- ✅ pmoaudiocache (cache audio)
+- ✅ pmocovers (cache covers)
+- ✅ SourceCacheManager (centralisé)
+- ✅ LazyProvider (téléchargement lazy)
+- ✅ pmodidl (DIDL-Lite)
+
+## Limitations et améliorations futures
+
+### Limitations actuelles
+
+1. **Search** : Pas d'exemple détaillé de search (optionnel dans le trait)
+2. **Authentification** : Mentionné mais pas d'exemple complet
+3. **Multi-format** : Pas d'exemple de source supportant plusieurs formats
+4. **Offline** : Pas de pattern pour source offline/synchronisation
+
+### Améliorations possibles
+
+1. Ajouter un exemple complet de search avec filtres
+2. Documenter l'intégration avec un système d'auth OAuth
+3. Ajouter un pattern pour sources multi-formats (FLAC/MP3/AAC)
+4. Documenter la gestion offline avec synchronisation
+
+## Fichiers créés
+
+- `Blackboard/Architecture/music_source.md` : Documentation complète (15 sections, ~800 lignes)
+
+## Conclusion
+
+Le document créé fournit un guide complet et pratique pour implémenter une nouvelle MusicSource. Il combine :
+
+- **Théorie** : Architecture, design patterns, principes
+- **Pratique** : Code complet, exemples réels, checklist
+- **Référence** : Schemas d'Object ID, intégrations, compatibilité
+
+Un développeur peut suivre ce guide étape par étape pour créer une nouvelle source musicale compatible avec l'écosystème PMOMusic, en s'inspirant des patterns éprouvés de Radio Paradise et Qobuz.

Blackboard/Report/openhome_queue_hybrid.md

@@ -0,0 +1,86 @@
+# Rapport : Queue OpenHome hybride avec cache de métadonnées
+
+## Objectif
+Transformer la queue OpenHome de stateless à hybride en ajoutant un cache de métadonnées. Cela permet au control point de mettre à jour les métadonnées des pistes même si le service OpenHome ne le permet pas nativement.
+
+## Problématique
+Les services OpenHome ne permettent pas de modifier les métadonnées d'une piste une fois qu'elle est dans la queue. Cela empêchait le control point de refléter les mises à jour de métadonnées effectuées par le média serveur.
+
+## Solution implémentée
+
+### 1. Structure de données
+Ajout d'un champ `metadata_cache: HashMap<u32, Option<TrackMetadata>>` dans `OpenHomeQueue` :
+- Clé : ID OpenHome de la track (pas l'index/position)
+- Valeur : Métadonnées optionnelles de la piste
+
+### 2. Enregistrement des métadonnées
+Les métadonnées sont enregistrées dans le cache dans toutes les méthodes qui manipulent des `PlaybackItem` :
+
+- **`add_playback_item`** : Enregistre les métadonnées lors de l'insertion
+- **`replace_item`** : Supprime l'ancien ID et enregistre le nouveau
+- **`replace_queue`** : Enregistre pour tous les nouveaux items
+- **`sync_queue`** et helpers :
+  - `replace_queue_preserve_current` : Enregistre pour les nouveaux items
+  - `replace_queue_with_pivot` : Met à jour les métadonnées du pivot
+  - `rebuild_playlist_section` : Met à jour pour items conservés et nouveaux
+  - `replace_queue_standard_lcs` : Met à jour pour items conservés et nouveaux
+
+### 3. Lecture depuis le cache
+Modification de `playback_item_from_entry` pour utiliser les métadonnées du cache en priorité :
+
+```rust
+let metadata = self.metadata_cache
+    .get(&entry.id)
+    .cloned()
+    .unwrap_or_else(|| entry.metadata());
+```
+
+### 4. Nettoyage du cache
+Le cache est nettoyé automatiquement lors des suppressions :
+- `delete_all()` → `metadata_cache.clear()`
+- `delete_id()` / `delete_id_if_exists()` → `metadata_cache.remove()`
+- Pas de nettoyage dans `queue_snapshot` (pas nécessaire, quelques entrées orphelines n'ont pas d'impact)
+
+### 5. API publique
+Ajout de la méthode publique `update_item_metadata` :
+
+```rust
+pub fn update_item_metadata(
+    &mut self,
+    index: usize,
+    metadata: Option<crate::model::TrackMetadata>,
+) -> Result<(), ControlPointError>
+```
+
+Cette méthode permet de mettre à jour manuellement les métadonnées d'un item à un index donné.
+
+## Points clés de l'implémentation
+
+### Utilisation de l'ID OpenHome (pas l'index)
+Le cache utilise l'ID OpenHome comme clé, pas la position dans la queue. Cela permet de suivre une piste même si sa position change.
+
+### Synchronisation intelligente
+Dans `sync_queue` :
+- **CASE 1** : Item courant PAS dans la nouvelle queue → métadonnées préservées en cache
+- **CASE 2** : Item courant DANS la nouvelle queue → métadonnées mises à jour avec celles de la nouvelle queue
+
+### Gestion des fuites mémoire
+Quelques entrées orphelines peuvent subsister si un autre control point modifie la playlist, mais :
+- Elles ne causent pas de bug (jamais consultées)
+- Impact mémoire négligeable
+- Naturellement écrasées lors des synchronisations
+
+## Fichiers modifiés
+- `pmocontrol/src/queue/openhome.rs` (unique fichier modifié)
+
+## Impact
+- ✅ Le control point peut maintenant afficher des métadonnées à jour
+- ✅ Les mises à jour du média serveur se reflètent dans la queue
+- ✅ Pas de changement de l'API publique (sauf ajout de `update_item_metadata`)
+- ✅ Pas d'impact sur les autres backends de queue
+- ✅ Compatible avec le comportement existant
+
+## Prochaines étapes suggérées
+1. Ajouter `update_item_metadata` aux autres backends de queue (InternalQueue)
+2. Exposer cette fonctionnalité au niveau du MediaRenderer
+3. Implémenter la synchronisation automatique des métadonnées depuis le MediaServer

Blackboard/Report/patch_position_info_for_stream.md

@@ -0,0 +1,15 @@
+# Rapport : Patch des informations de position pour les flux continus
+
+## Résumé
+Modification de la méthode `poll_and_emit_changes()` dans la crate `pmocontrol` pour corriger les données de position et durée lorsqu'un renderer diffuse un flux continu (webradio). La méthode détecte maintenant si un flux est en cours via `is_playing_a_stream()` et applique un traitement spécifique : extraction de la durée depuis les métadonnées DIDL, et calcul de la position relative depuis `track_start_time` (qui est déjà maintenu à jour lors des changements de métadonnées). Si aucune durée n'est disponible, la position et la durée sont mises à zéro/none.
+
+## Fichiers modifiés
+
+1. `pmocontrol/src/music_renderer/musicrenderer.rs`
+   - Modification de la méthode `poll_and_emit_changes()` pour patcher les informations de position lors de la détection d'un flux continu
+   - Ajout du logging au niveau info lors de la détection d'un flux continu
+   - Extraction conditionnelle de la durée depuis les métadonnées DIDL pour les streams
+   - Calcul de la position relative basé sur `track_start_time` (différence entre now et track_start_time)
+   - Retour de valeurs par défaut (zéro pour position, none pour duration) si aucune durée n'est disponible dans les métadonnées
+   - Préservation de la logique existante pour les médias réguliers (non-streams)
+   - Note : `track_start_time` est déjà maintenu à jour par la logique existante lors des changements de métadonnées

Blackboard/Report/pmoserver_ext.md

@@ -0,0 +1,77 @@
+# Rapport : Documentation du pattern pmoserver_ext
+
+## Contexte
+
+Documentation du pattern d'extension du PMOServer à travers plusieurs itérations basées sur les retours utilisateur.
+
+## Travail réalisé
+
+### Analyse des fichiers sources
+
+Les fichiers suivants ont été analysés pour extraire le pattern :
+
+- `pmoapp/src/lib.rs` : Pattern SPA avec RustEmbed
+- `pmocontrol/src/pmoserver_ext.rs` : API REST avec Control Point (1506+ lignes)
+- `pmoparadise/src/pmoserver_ext.rs` : API REST simple avec client externe
+- `pmoaudiocache/src/lib.rs` : Extension avec cache et fichiers
+- `pmomediaserver/src/paradise_streaming.rs` : Extension complexe avec streaming
+
+### Round 1 : Document initial
+
+Premier jet documentant exhaustivement tous les aspects des extensions (~850 lignes).
+
+### Round 2 : Recentrage sur le pattern
+
+**Annotation** : "se recentrer sur le sujet principal"
+
+**Actions** :
+- Réduction de ~850 à ~400 lignes
+- Suppression des digressions (OpenAPI détaillé, handlers spécifiques)
+- Focus sur l'anatomie du pattern en 5 étapes
+- Ajout d'une checklist et d'un exemple minimal
+
+**Résultat** : Document focalisé sur l'implémentation du pattern uniquement.
+
+### Round 3 : Réintégration OpenAPI
+
+**Annotation** : "Je trouve que le fait de devoir déclarer et documenter les URL dans OpenAPI / utopia était quelque chose d'important. Remets le."
+
+**Actions** :
+- Ajout d'une section complète "Documentation OpenAPI avec utoipa" (~260 lignes)
+- 5 sous-sections détaillées :
+  1. Configuration de base (dépendances Cargo)
+  2. Définition des schémas avec `#[derive(ToSchema)]`
+  3. Annotation des handlers avec `#[utoipa::path]`
+  4. Création de la structure `#[derive(OpenApi)]`
+  5. Exemple complet extrait de Radio Paradise
+- Mise à jour de la checklist avec section "Documentation OpenAPI"
+- Ajout des dépendances `utoipa` et `serde` dans la section références
+
+**Positionnement** : Section insérée après "Méthodes disponibles du serveur" et avant "Patterns courants", car elle fait partie intégrante de l'implémentation.
+
+## Structure finale du document
+
+1. **Vue d'ensemble** : Principe du pattern
+2. **Anatomie d'une extension** : 5 étapes détaillées
+3. **Méthodes disponibles du serveur** : API de `pmoserver::Server`
+4. **Documentation OpenAPI avec utoipa** : Guide complet en 5 étapes ⭐ *Ajouté au Round 3*
+5. **Patterns courants** : 3 exemples concrets
+6. **Gestion des opérations longues** : spawn_blocking, timeouts, background tasks
+7. **Checklist d'implémentation** : Organisée par catégories
+8. **Exemple complet minimal** : Code fonctionnel
+9. **Références** : Fichiers sources et dépendances
+
+## Résultat final
+
+Le document est maintenant :
+
+- **Complet** : Couvre tous les aspects essentiels incluant OpenAPI
+- **Structuré** : Progression logique de la configuration à l'implémentation
+- **Pratique** : Exemples de code concrets extraits du codebase
+- **Actionnable** : Checklist détaillée en 4 catégories
+
+Taille finale : ~660 lignes (avec section OpenAPI complète)
+
+## Fichiers modifiés
+
+- `Blackboard/Architecture/pmoserver_ext.md` : Document complet avec OpenAPI (660 lignes)

Blackboard/Report/stateful_music_renderer.md

@@ -0,0 +1,229 @@
+# Rapport : Rendre MusicRenderer complètement stateful
+
+## Résumé
+
+Refactorisation de l'architecture pour que chaque `MusicRenderer` gère son propre thread de surveillance (watcher), au lieu de déléguer le polling au `ControlPoint` centralisé. Cette modification améliore l'encapsulation, la cohérence des événements et prépare le terrain pour le support futur des notifications push (OpenHome, Chromecast).
+
+## Travail effectué
+
+### Phase 1 : Création du module watcher.rs
+
+**Fichier créé** : `pmocontrol/src/music_renderer/watcher.rs`
+
+Nouveau module contenant :
+- `WatchStrategy` enum avec trois variantes :
+  - `Polling { interval_ms: u64 }` - pour UPnP, LinkPlay, Arylic (500ms)
+  - `Push` - pour support futur des notifications push
+  - `Hybrid { polling_interval_ms: u64 }` - pour OpenHome et Chromecast
+- `WatchedState` struct pour le cache de détection des changements
+- Fonctions helper déplacées depuis `control_point.rs` :
+  - `playback_state_equal()`
+  - `playback_position_equal()`
+  - `compute_logical_playback_state()`
+  - `extract_track_metadata()`
+  - `parse_hms_to_secs()`
+- Tests unitaires pour les fonctions helper
+
+### Phase 2 : Extension de MusicRenderer
+
+**Fichier modifié** : `pmocontrol/src/music_renderer/musicrenderer.rs`
+
+Nouveaux champs ajoutés à la struct `MusicRenderer` :
+- `watched_state: Arc<Mutex<WatchedState>>` - cache pour détection des changements
+- `watcher_stop_flag: Arc<AtomicBool>` - signal d'arrêt du thread
+- `watcher_handle: Arc<Mutex<Option<JoinHandle<()>>>>` - handle du thread watcher
+
+Nouvelles méthodes publiques :
+- `start_watching()` - démarre le thread de surveillance (idempotent)
+- `stop_watching()` - arrête le thread gracieusement (idempotent)
+- `is_watching()` - retourne l'état du watcher
+
+Nouvelles méthodes internes :
+- `spawn_watcher_thread()` - crée le thread avec la stratégie appropriée
+- `watcher_loop()` - boucle principale de polling
+- `poll_and_emit_changes()` - poll le backend et émet les événements
+- `handle_state_change()` - logique d'auto-advance (déplacée depuis ControlPoint)
+- `emit_event()` - helper pour émettre un événement via le bus
+
+### Phase 3 : Modification du Registry
+
+**Fichier modifié** : `pmocontrol/src/registry.rs`
+
+Ajout des appels `start_watching()` / `stop_watching()` :
+- `push_renderer()` : appelle `start_watching()` quand un renderer arrive en ligne ou est créé
+- `device_says_byebye()` : appelle `stop_watching()` avant de marquer offline
+- `check_timeouts()` : appelle `stop_watching()` avant de marquer offline sur timeout
+
+### Phase 4 : Simplification du ControlPoint
+
+**Fichier modifié** : `pmocontrol/src/control_point.rs`
+
+Suppressions :
+- Thread de polling central (~140 lignes)
+- Struct `RendererRuntimeSnapshot`
+- Méthodes `emit_renderer_event()` et `handle_renderer_event()`
+- Fonctions helper déplacées vers `watcher.rs`
+
+### Phase 5 : Mise à jour du module
+
+**Fichier modifié** : `pmocontrol/src/music_renderer/mod.rs`
+
+Ajout de `pub mod watcher;` pour exposer le nouveau module.
+
+## Liste des fichiers
+
+### Fichiers créés
+
+| Fichier | Description |
+|---------|-------------|
+| `pmocontrol/src/music_renderer/watcher.rs` | Module watcher avec WatchStrategy, WatchedState et fonctions helper |
+
+### Fichiers modifiés
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Ajout champs watcher, méthodes start/stop_watching, logique auto-advance |
+| `pmocontrol/src/music_renderer/mod.rs` | Ajout `pub mod watcher;` |
+| `pmocontrol/src/registry.rs` | Appels start/stop_watching dans push_renderer, device_says_byebye, check_timeouts |
+| `pmocontrol/src/control_point.rs` | Suppression polling central, RendererRuntimeSnapshot, handle_renderer_event, fonctions helper |
+
+## Notes techniques
+
+- Le signal d'arrêt utilise `AtomicBool` avec `Ordering::SeqCst` pour garantir la visibilité entre threads
+- Les méthodes `start_watching()` et `stop_watching()` sont idempotentes
+- Le thread watcher est nommé `watcher-{friendly_name}` pour faciliter le debug
+- L'intervalle de polling est de 500ms (volume/mute toutes les 2 ticks = 1s)
+- La logique `compute_logical_playback_state()` compense les bugs des devices Arylic/LinkPlay
+- L'auto-advance est maintenant géré directement dans le watcher du MusicRenderer
+
+## Round 2 : Vérification transition offline → online
+
+### Problème identifié
+
+La méthode `refresh_device_presence()` dans `registry.rs` n'appelait pas `start_watching()` quand un renderer passait de offline à online. Cette méthode est appelée lors de la réception de messages SSDP Alive.
+
+### Correction appliquée
+
+**Fichier modifié** : `pmocontrol/src/registry.rs`
+
+Ajout de l'appel `renderer.start_watching()` dans `refresh_device_presence()` quand `was_online == false`.
+
+### Points de démarrage du watcher vérifiés
+
+| Méthode | Situation | `start_watching()` appelé |
+|---------|-----------|---------------------------|
+| `push_renderer()` | Nouveau renderer | Oui |
+| `push_renderer()` | Renderer existant, était offline | Oui |
+| `refresh_device_presence()` | Renderer existant, était offline | Oui (corrigé) |
+
+### Points d'arrêt du watcher vérifiés
+
+| Méthode | Situation | `stop_watching()` appelé |
+|---------|-----------|--------------------------|
+| `device_says_byebye()` | SSDP ByeBye reçu | Oui |
+| `check_timeouts()` | Timeout dépassé | Oui |
+
+## Round 3 : Audit complet de la logique offline/online
+
+Suite à la découverte du manque dans le Round 2, un audit complet de tous les chemins offline/online a été effectué.
+
+### Chemins qui appellent `start_watching()`
+
+| Chemin | Fonction | Ligne | Condition | Status |
+|--------|----------|-------|-----------|--------|
+| Nouveau renderer découvert | `push_renderer()` | 180, 194 | Création nouvelle entry | ✅ OK |
+| Renderer existant, ajout renderer à entry | `push_renderer()` | 169 | Entry existe sans renderer | ✅ OK |
+| Renderer existant revient online | `push_renderer()` | 160 | `!was_online` | ✅ OK |
+| SSDP Alive pour device connu | `refresh_device_presence()` | 269 | `!was_online` | ✅ OK (corrigé Round 2) |
+
+### Chemins qui appellent `stop_watching()`
+
+| Chemin | Fonction | Ligne | Condition | Status |
+|--------|----------|-------|-----------|--------|
+| SSDP ByeBye reçu | `device_says_byebye()` | 289 | Renderer présent | ✅ OK |
+| Timeout dépassé | `check_timeouts()` | 308 | `elapsed > max_age` | ✅ OK |
+
+### Analyse des flux
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    FLUX ONLINE                                   │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  SSDP Discovery ──► push_renderer() ──► start_watching() ✅     │
+│                                                                  │
+│  SSDP Alive (nouveau UDN) ──► push_renderer() ──► start_watching() ✅ │
+│                                                                  │
+│  SSDP Alive (UDN connu, online) ──► refresh_device_presence()   │
+│                                     (pas de start car déjà en marche) │
+│                                                                  │
+│  SSDP Alive (UDN connu, offline) ──► refresh_device_presence()  │
+│                                       ──► start_watching() ✅    │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│                    FLUX OFFLINE                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  SSDP ByeBye ──► device_says_byebye() ──► stop_watching() ✅    │
+│                                                                  │
+│  Timeout ──► check_timeouts() ──► stop_watching() ✅            │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Conclusion
+
+**Tous les chemins sont correctement gérés.** Chaque transition offline→online appelle `start_watching()` et chaque transition online→offline appelle `stop_watching()`.
+
+L'idempotence des méthodes `start_watching()` et `stop_watching()` garantit qu'aucun problème ne survient en cas d'appels multiples.
+
+## Round 4 : Centralisation de la gestion du watcher
+
+### Problème identifié
+
+Les appels à `start_watching()` et `stop_watching()` étaient dispersés dans `registry.rs` (6 emplacements), augmentant le risque d'oubli (comme découvert en Round 2).
+
+### Solution implémentée
+
+Centralisation de la gestion du watcher dans `MusicRenderer` lui-même :
+
+1. **Constructeur** (`from_renderer_info_with_bus()`) : appelle automatiquement `start_watching()` à la fin, car le renderer est créé avec `online = true`
+
+2. **`has_been_seen_now()`** : appelle automatiquement `start_watching()` si transition offline→online
+
+3. **`mark_as_offline()`** : appelle automatiquement `stop_watching()` avant de passer offline
+
+### Fichiers modifiés
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmocontrol/src/music_renderer/musicrenderer.rs` | Ajout `start_watching()` dans constructeur, dans `has_been_seen_now()` et `stop_watching()` dans `mark_as_offline()` |
+| `pmocontrol/src/registry.rs` | Suppression de tous les appels manuels à `start_watching()` et `stop_watching()` |
+
+### Avantages
+
+- **Encapsulation** : la logique watcher est entièrement gérée par `MusicRenderer`
+- **Impossible d'oublier** : les transitions sont automatiquement gérées
+- **Code simplifié** : `registry.rs` ne contient plus de logique watcher
+- **Idempotence** : les appels multiples sont sans effet grâce aux guards existants
+
+### Nouvelle architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    GESTION AUTOMATIQUE DU WATCHER               │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Création MusicRenderer ──► constructeur ──► start_watching()   │
+│                                                                  │
+│  has_been_seen_now() ──► si !was_online ──► start_watching()    │
+│                                                                  │
+│  mark_as_offline() ──► stop_watching() ──► online = false       │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Compilation
+
+Le projet compile sans erreur.

Blackboard/Rules.md

@@ -0,0 +1,184 @@
+# Règles de développement PMOMusic
+
+## Contexte projet
+
+**PMOMusic** : Système audio HiFi basé sur UPnP/DLNA (LossLess/Bit-Perfect uniquement).
+
+**Technologies** :
+- Backend : Rust
+- Frontend : Vue.js (TypeScript/JavaScript)
+
+**Composants** : Media Server, Control Point, Media Renderer
+
+**Développement** : Collaboration humain-LLM (Claude/ChatGPT/Ollama)
+
+---
+
+## Règles Rust (Cargo workspace)
+
+### Gestion des dépendances
+
+**⚠️ OBLIGATOIRE** : Les dépendances doivent être ajoutées au niveau **workspace** autant que possible.
+
+1. Ajouter la dépendance dans `Cargo.toml` racine (section `[workspace.dependencies]`)
+2. Référencer avec `{ workspace = true }` dans le `Cargo.toml` de la crate
+
+**Exemple** :
+```toml
+# Cargo.toml (racine workspace)
+[workspace.dependencies]
+rand = "0.9"
+
+# pmocontrol/Cargo.toml
+[dependencies]
+rand = { workspace = true }
+```
+
+**Exceptions** : Dépendances spécifiques à une seule crate avec version très particulière.
+
+---
+
+## Prérequis des tâches
+
+### Spécification des crates cibles
+
+**⚠️ CRITIQUE** : Le LLM doit **REFUSER** d'exécuter une tâche si la ou les crates concernées ne sont pas explicitement spécifiées dans le fichier `Todo/{nom}.md`.
+
+**Informations requises** :
+- Nom de la ou des crates à modifier
+- Chemin relatif si nécessaire (ex: `pmocontrol/src/...`)
+
+**En cas d'absence** :
+- Le LLM demande clarification à l'humain
+- Ne pas deviner ou supposer les crates concernées
+
+---
+
+## Workflow Blackboard
+
+### Structure
+
+```
+Blackboard/
+├── ToThinkAbout/    # Réflexion, idées, architecture
+├── Architecture/    # Documentation d'architecture validée
+├── Todo/            # Tâches à réaliser
+├── Report/          # Rapports de tâches réalisées
+├── ToDiscuss/       # Tâches incomplètes nécessitant discussion
+├── Done/            # Tâches terminées (synthèses)
+└── Rules.md         # Ce fichier
+```
+
+### Cycle de vie d'une tâche
+
+```mermaid
+flowchart LR
+    THINK[ToThinkAbout] -->|Spécification| TODO[Todo]
+    TODO -->|Implémentation| REPORT[Report]
+    REPORT -->|Humain décide| DONE[Done]
+    REPORT -->|Humain décide| DISCUSS[ToDiscuss]
+    DISCUSS -->|Reprise travail| REPORT
+```
+
+### Règles strictes
+
+#### 1. Phase de réflexion (ToThinkAbout)
+- **Collaboration** : Humain et LLM peuvent modifier
+- **But** : Explorer idées, définir architecture
+- **Sortie** : Documents de spécification → `Todo/`
+
+#### 2. Phase de réalisation (Todo → Report)
+- **Input** : Fichier `Todo/{nom}.md`
+- **Action** : LLM implémente la tâche
+- **Output** : Fichier `Report/{nom}.md` (même nom obligatoire)
+- **Contenu du rapport** :
+  - Résumé **court** du travail effectué (2-3 phrases maximum)
+  - Liste **exhaustive** des fichiers créés/modifiés avec leur chemin complet
+  - **INTERDIT** : Rapport détaillé dans la discussion (uniquement dans `Report/`)
+  - **INTERDIT** : Explication technique détaillée, code d'exemple, architecture
+  
+- **Réponse dans la discussion (après implémentation)** :
+  - Message **très bref** confirmant la fin de la tâche
+  - Référence au fichier `Report/{nom}.md` pour les détails
+  - **Format attendu** : "Tâche terminée. Voir `Report/{nom}.md` pour la liste des modifications."
+  - **PAS de** : résumé détaillé, explication du code, liste des avantages, etc.
+
+#### 3. Décision humaine (Report → Done ou ToDiscuss)
+
+**⚠️ CRITIQUE** : Seul l'humain décide de la destination. Le LLM ne doit JAMAIS déplacer ou classer une tâche.
+
+**Cas 1 : Tâche complète** → `Done/`
+- Humain déplace `Todo/{nom}.md` → `Done/{nom}.md`
+- LLM crée une synthèse (tâche originale + rapport)
+- Contenu final dans `Done/{nom}.md`
+
+**Cas 2 : Tâche incomplète** → `ToDiscuss/`
+- Humain déplace `Todo/{nom}.md` → `ToDiscuss/{nom}.md`
+- Humain ajoute annotations/remarques dans `ToDiscuss/{nom}.md`
+- Lors de la reprise :
+  - LLM lit les annotations
+  - Complète `Report/{nom}.md` avec les modifications
+  - Nouveau cycle de validation
+
+#### 4. Documentation architecture (Architecture/)
+- Contient les documents d'architecture validés et stables
+- Référence pour patterns de code (ex: `pmoconfig_ext.md`, `pmoserver_ext.md`)
+- Ne pas modifier sans validation explicite
+
+---
+
+## Versioning (Jujutsu)
+
+**Système** : [Jujutsu (jj)](https://github.com/jj-vcs/jj)  
+**Repository** : `https://gargoton.petite-maison-orange.fr/eric/pmomusic.git`
+
+### Commandes Makefile
+
+| Commande | Action | Description |
+|----------|--------|-------------|
+| `make jjnew` | Nouveau commit | Documente le commit actuel (`jj auto-describe`) puis `jj new` |
+| `make jjpush` | Push vers Git | Documente le commit puis `jj git push --change @`<br/>→ Crée branche + PR sur le serveur |
+| `make jjfetch` | Récupération | `jj git fetch` puis `jj new main@origin`<br/>→ Après validation du PR |
+
+### Gestion version
+
+- **Source de vérité** : `PMOMusic/Cargo.toml`
+- **Sync** : `version.txt` (généré par Makefile)
+- **Incrémentation** : `make bump-version` (avant `jjpush`)
+
+---
+
+## Checklist LLM
+
+### Avant de commencer une tâche
+- [ ] Lire `Todo/{nom}.md`
+- [ ] Vérifier les références à `Architecture/` si mentionnées
+- [ ] Comprendre les contraintes (HiFi, LossLess, UPnP/DLNA)
+
+### Pendant la réalisation
+- [ ] Suivre les patterns d'architecture existants
+- [ ] Utiliser Rust (backend) ou Vue.js/TypeScript (frontend)
+- [ ] Tester le code si applicable
+
+### Après la réalisation
+- [ ] Créer `Report/{nom}.md` (même nom que la tâche)
+- [ ] Lister fichiers créés/modifiés
+- [ ] **NE PAS** déplacer la tâche
+- [ ] **NE PAS** écrire de rapport détaillé dans la discussion
+- [ ] Attendre la décision humaine
+
+### Si tâche en ToDiscuss
+- [ ] Lire annotations ajoutées par l'humain
+- [ ] Expliquer dans `Report/{nom}.md` comment les remarques sont prises en compte
+- [ ] Reprise du cycle de validation
+
+---
+
+## Diagrammes Mermaid
+
+Tous les diagrammes d'architecture doivent utiliser Mermaid. La commande `make blackboard-html` génère une version HTML consultable avec rendu des diagrammes.
+
+**Syntaxe stricte** :
+- Labels de subgraph : `subgraph Name[Label]` (pas de guillemets doubles)
+- Balises HTML : `Node["Text<br/>Multi"]` (guillemets doubles)
+- Formes spéciales : `DB[("database")]`, `Decision{"Question?"}` (guillemets)

Blackboard/Rules_optimal.md

@@ -0,0 +1,137 @@
+# PMOMusic - Règles LLM (IMPÉRATIF)
+
+## 🎯 Projet
+Audio HiFi UPnP/DLNA. Backend Rust, Frontend Vue.js/TypeScript.
+
+**Environnement** : `source .claude-env` (racine projet) AVANT toute commande.
+
+---
+
+## ⛔ INTERDICTIONS (0 EXCEPTION)
+
+1. **JAMAIS déplacer/créer fichiers** dans `Blackboard/` (seul humain décide)
+2. **JAMAIS commencer** sans crates explicites dans `Todo/{nom}.md` → REFUSER
+3. **JAMAIS compiler/tester** (`cargo`, `npm`) → TOUJOURS demander à humain
+4. **JAMAIS détailler** implémentation dans discussion → UN message : "Tâche terminée. Voir `Report/{nom}.md`..."
+
+---
+
+## 📋 WORKFLOW (STRICT)
+
+```
+1. LIRE Todo/{nom}.md
+   Crates spécifiées ? NON → ARRÊTER, demander | OUI → Continuer
+   
+2. IMPLÉMENTER
+   Patterns Architecture/ si référencés
+   DEMANDER compilation : "Compilez `cargo build -p {crate}`, renvoyez erreurs"
+   Erreurs ? OUI → Corriger, redemander | NON → Continuer
+   
+3. CRÉER Report/{nom}.md
+   - Résumé (2-3 phrases, SANS code/détails techniques)
+   - Fichiers modifiés (chemins complets)
+   - Modifications SÉMANTIQUES (concepts, PAS lignes code)
+   ÉCRIRE dans chat : "Tâche terminée. Voir `Report/{nom}.md`..."
+   ARRÊTER (ne rien déplacer)
+   
+4. SI humain déplace Todo/{nom}.md → Done/{nom}.md
+   ALORS écrire synthèse COMPLÈTE dans Done/{nom}.md
+```
+
+---
+
+## 🔧 RÈGLES TECHNIQUES
+
+**Dépendances** : TOUJOURS workspace (`Cargo.toml` racine) sauf exception justifiée
+```toml
+# ✅ workspace.dependencies puis { workspace = true }
+# ❌ version directe dans crate
+```
+
+---
+
+## 📂 BLACKBOARD
+
+| Dossier | LLM crée | LLM déplace | Humain déplace |
+|---------|----------|-------------|----------------|
+| `Todo/` | ❌ | ❌ | ✅ → Done/ToDiscuss |
+| `Report/` | ✅ | ❌ | ❌ |
+| `Done/` | ❌ (écrit après déplacement) | ❌ | ✅ |
+| `ToDiscuss/` | ❌ | ❌ | ✅ |
+
+---
+
+## ✅ CHECKLIST
+
+**Avant** :
+- [ ] `source .claude-env`
+- [ ] Crates dans `Todo/{nom}.md` ? NON → ARRÊTER
+
+**Pendant** :
+- [ ] Patterns existants
+- [ ] Workspace dependencies
+- [ ] NE PAS compiler
+
+**Après** :
+- [ ] `Report/{nom}.md` : résumé court + fichiers + modifs sémantiques (SANS code)
+- [ ] Chat : "Tâche terminée. Voir `Report/{nom}.md`..." (RIEN d'autre)
+- [ ] NE PAS déplacer `Todo/{nom}.md`
+
+---
+
+## 📝 TEMPLATES
+
+### Report/{nom}.md
+```markdown
+# Rapport : {titre}
+
+## Résumé
+{2-3 phrases SANS code}
+
+## Fichiers modifiés
+1. `chemin/fichier.rs`
+   - {Modification sémantique 1}
+   - {Modification sémantique 2}
+```
+
+**Modif sémantique** = concept (ex: "Ajout cache"), PAS ligne code (ex: ❌ "Ajout `let x = 5;`")
+
+### Discussion
+```
+Tâche terminée. Voir `Report/{nom}.md` pour la liste des modifications.
+```
+
+### Done/{nom}.md (après déplacement humain)
+```markdown
+# {Titre}
+## Spécification
+{Copie Todo/ complète}
+## Implémentation
+{Détails complets par fichier}
+## Tests/Validation
+## Conclusion
+```
+
+---
+
+## 🎯 6 RÈGLES D'OR
+
+1. JAMAIS déplacer fichiers Blackboard
+2. EXIGER crates dans Todo/ (sinon REFUSER)
+3. JAMAIS compiler (demander humain)
+4. Report court SANS code/détails
+5. Discussion : 1 ligne après implémentation
+6. Done/ : écrire APRÈS déplacement humain
+
+---
+
+## 🔍 AUTO-VÉRIF (chaque message)
+
+- [ ] Déplacé fichier ? → ERREUR
+- [ ] >2 lignes chat après implémentation ? → ERREUR  
+- [ ] Commencé sans vérif crates ? → ERREUR
+- [ ] Compilé moi-même ? → ERREUR
+- [ ] Créé Done/ ? → ERREUR
+- [ ] Supposé code compile ? → ERREUR
+
+**ERREUR détectée** → ARRÊTER immédiatement

Blackboard/ToDiscuss/Pinnable_cache_item.md

@@ -0,0 +1,8 @@
+**Il faut suivre les instructions générales placées dans le fichier : Blackboard/Rules.md**
+
+
+La crâte PMOcache, implémente un system de cache qui pourrait être étendu pour permettre une utilisation plus large. L'idée est de modifier les règles de déletion des items. Actuellement le cache a une capacité maximale. Et les items ont des TTL, qui peuvent être non définies. Lorsque le cash est plein, les plus vieux items en termes d'utilisation ou ceux qui ont dépassé leur TTL peuvent être détruits. Je propose de rajouter une fonctionnalité qui permet d'épingler certains items pour les rendre non destructibles. Ils pourraient aussi sortir du comptage général des items pour savoir si le cache est plein.
+
+Il faudra modifier la structure de la base de données. Ajouter une colonne indiquant cette propriété. Mettre une règle métier en disant qu'on ne peut pas être à la fois épinglés et avec un TTL.
+
+On se moque de maintenir la compatibilité avec la base de données actuelle, il n'y a pas à prévoir de phase de transition. Nous sommes en période de développement.

Blackboard/ToDiscuss/Support_AAC_streaming_pmoflac.md

@@ -0,0 +1,586 @@
+** Tu dois suivre scrupuleusement les règles définies dans le fichier [@Rules.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules.md) **
+
+** Cette tâche est une tâche de recherche et développement. Elle doit conduire à un prototype fonctionnel et/ou un rapport technique sur la faisabilité. **
+
+# Support du streaming AAC dans pmoflac
+
+## Contexte
+
+Actuellement, `pmoflac` supporte le décodage streaming pour :
+- ✅ MP3 (via `minimp3`)
+- ✅ FLAC (via `claxon`)
+- ✅ Ogg Vorbis (via `lewton`)
+- ✅ Ogg Opus (via `opus`)
+- ✅ WAV (parsing manuel)
+- ✅ AIFF (parsing manuel)
+
+**Manque critique** : Pas de support AAC, pourtant très utilisé pour :
+- Streams radio live (Radio France, etc.)
+- Podcasts
+- Services de streaming musicaux
+- Fichiers M4A/MP4
+
+## Problématique
+
+Le décodage AAC en **streaming infini** (radio live) est actuellement impossible dans `pmoflac`, ce qui force à :
+- Soit faire un proxy passthrough (pas de transcodage FLAC)
+- Soit utiliser une redirection 302 (pas de tracking)
+
+Cela empêche d'avoir une expérience uniforme où toutes les sources servent du FLAC.
+
+## Objectif
+
+**Investiguer et prototyper** le support du décodage AAC streaming dans `pmoflac`, en s'inspirant de l'architecture existante (MP3, Ogg, etc.).
+
+## Recherches préliminaires
+
+### 1. Symphonia avec ReadOnlySource
+
+[Symphonia](https://github.com/pdeljanov/Symphonia) est la bibliothèque Rust la plus complète pour le décodage audio. Elle fournit :
+
+- **`ReadOnlySource`** : Wrapper pour sources non-seekable (streams infinis)
+- **`AdtsReader`** : Format reader spécifique pour ADTS (AAC streaming)
+- **`symphonia-codec-aac`** : Décodeur AAC-LC (Low Complexity)
+
+**Points d'attention** :
+- [Issue connue](https://github.com/RustAudio/rodio/issues/580) : Certains formats peuvent quand même réclamer le seek
+- Nécessite de tester avec un vrai stream ADTS
+
+### 2. Format ADTS
+
+[ADTS](https://wiki.multimedia.cx/index.php/ADTS) (Audio Data Transport Stream) est le format AAC conçu pour le streaming :
+
+- Auto-synchronisant : chaque frame a un header (12 bits `0xFFF`)
+- Pas de container nécessaire (MP4, M4A)
+- Utilisé par les radios en streaming
+- Chaque frame contient ses métadonnées (sample rate, channels, etc.)
+
+**Structure** :
+```
+Frame 1: [ADTS Header 7-9 bytes][AAC Data]
+Frame 2: [ADTS Header 7-9 bytes][AAC Data]
+...
+```
+
+### 3. Alternative : fdk-aac
+
+[Bindings Rust pour fdk-aac](https://github.com/haileys/fdk-aac-rs) (bibliothèque Fraunhofer) :
+
+**Avantages** :
+- ✅ Décodeur de référence (qualité maximale)
+- ✅ Support explicite du streaming chunk-by-chunk
+- ✅ Buffer interne géré automatiquement
+- ✅ Pas besoin de seek
+
+**Inconvénients** :
+- ❌ Dépendance C (libfdk-aac)
+- ❌ Licence restrictive (non-commerciale pour certaines versions)
+- ❌ Compilation plus complexe
+
+## Plan d'investigation
+
+### Round 1 : Prototype Symphonia ADTS
+
+**Objectif** : Tester si Symphonia peut décoder un stream AAC infini avec `ReadOnlySource` + `AdtsReader`.
+
+#### Étapes
+
+1. **Créer un module de test** : `pmoflac/tests/aac_streaming_test.rs`
+
+2. **Implémenter un décodeur basique** :
+   ```rust
+   use symphonia::core::io::{MediaSourceStream, ReadOnlySource};
+   use symphonia::default::get_probe;
+   use symphonia_codec_aac::AdtsReader;
+   
+   async fn decode_aac_stream_test<R: AsyncRead + Unpin>(
+       reader: R
+   ) -> Result<Vec<u8>> {
+       // Wrapper AsyncRead → Read synchrone (pattern pmoflac)
+       let sync_reader = blocking_reader_from_async(reader);
+       
+       // ReadOnlySource pour stream infini
+       let source = ReadOnlySource::new(sync_reader);
+       let mss = MediaSourceStream::new(Box::new(source), Default::default());
+       
+       // Probe avec hint AAC/ADTS
+       let mut hint = Hint::new();
+       hint.with_extension("aac");
+       
+       let mut format = get_probe()
+           .format(&hint, mss, &Default::default(), &Default::default())?;
+       
+       // Récupérer le track audio
+       let track = format.default_track().unwrap();
+       let mut decoder = symphonia::default::get_codecs()
+           .make(&track.codec_params, &Default::default())?;
+       
+       let mut pcm_output = Vec::new();
+       
+       // Décoder frame par frame (boucle infinie jusqu'à disconnect)
+       loop {
+           match format.next_packet() {
+               Ok(packet) => {
+                   let decoded = decoder.decode(&packet)?;
+                   // Convertir en PCM et accumuler
+                   let samples = convert_to_pcm_bytes(decoded);
+                   pcm_output.extend_from_slice(&samples);
+               }
+               Err(symphonia::core::errors::Error::IoError(e)) 
+                   if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                   break; // Stream fermé
+               }
+               Err(e) => return Err(e.into()),
+           }
+       }
+       
+       Ok(pcm_output)
+   }
+   ```
+
+3. **Tester avec un fichier AAC ADTS statique** :
+   - Télécharger un échantillon AAC ADTS
+   - Vérifier que le décodage fonctionne
+   - Comparer PCM output avec ffmpeg
+
+4. **Tester avec un stream Radio France live** :
+   ```rust
+   #[tokio::test]
+   #[ignore = "Requires network"]
+   async fn test_decode_radiofrance_stream() {
+       let stream_url = "https://icecast.radiofrance.fr/fip-hifi.aac";
+       let response = reqwest::get(stream_url).await.unwrap();
+       let reader = response.bytes_stream();
+       
+       // Lire 10 secondes de stream
+       let pcm = decode_aac_stream_test(reader).await.unwrap();
+       
+       assert!(!pcm.is_empty());
+       // Vérifier format PCM (44.1kHz ou 48kHz, stéréo, 16-bit)
+   }
+   ```
+
+#### Critères de succès Round 1
+
+- ✅ Le décodeur accepte un `ReadOnlySource` sans erreur de seek
+- ✅ Les frames ADTS sont correctement parsées
+- ✅ Le décodage AAC → PCM fonctionne
+- ✅ Un stream live (infini) peut être décodé sans plantage
+- ✅ Le PCM output est valide (vérifiable avec `ffplay`)
+
+#### Livrables Round 1
+
+1. **Module de test** : `pmoflac/tests/aac_streaming_test.rs`
+2. **Rapport technique** : `Blackboard/Report/Support_AAC_streaming_pmoflac.md`
+   - Résultats des tests
+   - Problèmes rencontrés (seek, parsing, etc.)
+   - Métriques de performance (CPU, latence)
+   - Comparaison qualité avec ffmpeg
+
+---
+
+### Round 2 : Intégration dans pmoflac (si Round 1 réussit)
+
+**Objectif** : Intégrer le décodeur AAC dans l'architecture streaming de `pmoflac`.
+
+#### Fichiers à créer/modifier
+
+**1. `pmoflac/src/aac.rs`** (nouveau)
+
+```rust
+use symphonia::core::io::{MediaSourceStream, ReadOnlySource};
+use tokio::sync::mpsc;
+use crate::{
+    common::ChannelReader,
+    decoder_common::{spawn_ingest_task, spawn_writer_task, DecodedStream},
+    pcm::StreamInfo,
+};
+
+pub type AacDecodedStream = DecodedStream<AacError>;
+
+#[derive(thiserror::Error, Debug)]
+pub enum AacError {
+    #[error("AAC decode error: {0}")]
+    Decode(String),
+    #[error("I/O error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Channel closed")]
+    ChannelClosed,
+}
+
+/// Décoder un stream AAC/ADTS en PCM
+pub async fn decode_aac_stream<R>(reader: R) -> Result<AacDecodedStream, AacError>
+where
+    R: AsyncRead + Unpin + Send + 'static,
+{
+    // Suivre le pattern existant (MP3, FLAC, etc.)
+    let (ingest_tx, ingest_rx) = mpsc::channel(CHANNEL_CAPACITY);
+    spawn_ingest_task(reader, ingest_tx);
+    
+    let (pcm_tx, pcm_rx) = mpsc::channel(CHANNEL_CAPACITY);
+    let (pcm_reader, pcm_writer) = tokio::io::duplex(DUPLEX_BUFFER_SIZE);
+    let (info_tx, info_rx) = oneshot::channel::<Result<StreamInfo, AacError>>();
+    
+    let blocking_handle = tokio::task::spawn_blocking(move || -> Result<(), AacError> {
+        let mut channel_reader = ChannelReader::<AacError>::new(ingest_rx);
+        
+        // ReadOnlySource pour stream infini
+        let source = ReadOnlySource::new(&mut channel_reader);
+        let mss = MediaSourceStream::new(Box::new(source), Default::default());
+        
+        // Probe AAC/ADTS
+        let mut hint = Hint::new();
+        hint.with_extension("aac");
+        
+        let mut format = get_probe()
+            .format(&hint, mss, &Default::default(), &Default::default())
+            .map_err(|e| AacError::Decode(e.to_string()))?;
+        
+        let track = format.default_track()
+            .ok_or_else(|| AacError::Decode("No audio track found".into()))?;
+        
+        let mut decoder = get_codecs()
+            .make(&track.codec_params, &Default::default())
+            .map_err(|e| AacError::Decode(e.to_string()))?;
+        
+        // Extraire StreamInfo
+        let codec_params = &track.codec_params;
+        let info = StreamInfo {
+            sample_rate: codec_params.sample_rate.unwrap_or(48000),
+            channels: codec_params.channels.unwrap().count() as u8,
+            bits_per_sample: 16, // AAC decode to 16-bit PCM
+            total_samples: None, // Stream infini
+            max_block_size: 0,
+            min_block_size: 0,
+        };
+        
+        if info_tx.send(Ok(info.clone())).is_err() {
+            return Ok(());
+        }
+        
+        // Boucle de décodage
+        loop {
+            match format.next_packet() {
+                Ok(packet) => {
+                    let decoded = decoder.decode(&packet)
+                        .map_err(|e| AacError::Decode(e.to_string()))?;
+                    
+                    // Convertir AudioBufferRef → bytes PCM
+                    let pcm_bytes = convert_audio_buffer_to_bytes(decoded, &info);
+                    
+                    if pcm_tx.blocking_send(Ok(pcm_bytes)).is_err() {
+                        break; // Reader fermé
+                    }
+                }
+                Err(symphonia::core::errors::Error::IoError(e)) 
+                    if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                    break; // Stream terminé normalement
+                }
+                Err(e) => {
+                    let msg = e.to_string();
+                    let _ = pcm_tx.blocking_send(Err(AacError::Decode(msg.clone())));
+                    return Err(AacError::Decode(msg));
+                }
+            }
+        }
+        
+        Ok(())
+    });
+    
+    let writer_handle = spawn_writer_task(pcm_rx, pcm_writer, blocking_handle, "aac-decode");
+    let info = info_rx.await.map_err(|_| AacError::ChannelClosed)??;
+    let reader = ManagedAsyncReader::new("aac-decode-writer", pcm_reader, writer_handle);
+    
+    Ok(DecodedStream::new(info, reader))
+}
+
+/// Convertir AudioBufferRef Symphonia → bytes PCM little-endian
+fn convert_audio_buffer_to_bytes(
+    audio_buffer: AudioBufferRef,
+    info: &StreamInfo,
+) -> Vec<u8> {
+    // Implémenter conversion selon le type de buffer
+    // (S16, S24, S32, F32, etc.) → i16 little-endian interleaved
+    // ...
+}
+```
+
+**2. `pmoflac/src/lib.rs`** (modifier)
+
+```rust
+pub mod aac;
+
+pub use aac::{decode_aac_stream, AacDecodedStream, AacError};
+```
+
+**3. `pmoflac/src/autodetect.rs`** (modifier)
+
+Ajouter la détection AAC/ADTS :
+
+```rust
+fn detect_format(bytes: &[u8]) -> Option<DetectedFormat> {
+    // ... détections existantes ...
+    
+    // Détecter ADTS AAC (syncword 0xFFF)
+    if is_adts(bytes) {
+        return Some(DetectedFormat::Aac);
+    }
+    
+    None
+}
+
+fn is_adts(bytes: &[u8]) -> bool {
+    if bytes.len() < 2 {
+        return false;
+    }
+    // ADTS syncword: 12 bits à 1 (0xFFF)
+    bytes[0] == 0xFF && (bytes[1] & 0xF0) == 0xF0
+}
+
+pub enum DecodedAudioStream {
+    // ... variants existants ...
+    Aac(AacDecodedStream),
+}
+```
+
+**4. `pmoflac/src/transcode.rs`** (modifier)
+
+Ajouter AAC au transcodeur :
+
+```rust
+pub enum AudioCodec {
+    // ... codecs existants ...
+    Aac,
+}
+
+pub async fn transcode_to_flac_stream<R>(
+    reader: R,
+    options: TranscodeOptions,
+) -> Result<TranscodeToFlac, TranscodeError>
+where
+    R: AsyncRead + Unpin + Send + 'static,
+{
+    // ... détection auto ...
+    
+    match decoded {
+        // ... cas existants ...
+        DecodedAudioStream::Aac(stream) => {
+            transcode_from_decoded(AudioCodec::Aac, stream, options.encoder_options).await
+        }
+    }
+}
+```
+
+**5. `pmoflac/Cargo.toml`** (modifier)
+
+```toml
+[dependencies]
+# ... dépendances existantes ...
+
+# AAC support
+symphonia = { version = "0.5", features = ["aac", "isomp4"], optional = true }
+symphonia-core = { version = "0.5", optional = true }
+symphonia-codec-aac = { version = "0.5", optional = true }
+
+[features]
+default = ["mp3", "ogg", "opus", "wav", "aiff"]
+aac = ["dep:symphonia", "dep:symphonia-core", "dep:symphonia-codec-aac"]
+all = ["mp3", "ogg", "opus", "wav", "aiff", "aac"]
+```
+
+#### Tests Round 2
+
+**Tests unitaires** :
+```rust
+#[tokio::test]
+async fn test_decode_aac_to_pcm() {
+    let aac_data = include_bytes!("../test-data/sample.aac");
+    let stream = decode_aac_stream(&aac_data[..]).await.unwrap();
+    
+    let info = stream.info();
+    assert_eq!(info.sample_rate, 48000);
+    assert_eq!(info.channels, 2);
+    
+    // Lire quelques samples
+    let mut buffer = vec![0u8; 4096];
+    let mut reader = stream;
+    let n = reader.read(&mut buffer).await.unwrap();
+    assert!(n > 0);
+}
+```
+
+**Tests intégration** :
+```rust
+#[tokio::test]
+#[ignore = "Integration test - network required"]
+async fn test_transcode_radiofrance_to_flac() {
+    let stream_url = "https://icecast.radiofrance.fr/fip-hifi.aac";
+    let response = reqwest::get(stream_url).await.unwrap();
+    let reader = response.bytes_stream();
+    
+    let transcoded = transcode_to_flac_stream(
+        reader,
+        TranscodeOptions::default()
+    ).await.unwrap();
+    
+    assert_eq!(transcoded.input_codec(), AudioCodec::Aac);
+    assert_eq!(transcoded.input_stream_info().sample_rate, 48000);
+    
+    // Lire 5 secondes de FLAC
+    let mut output = Vec::new();
+    let mut stream = transcoded.into_stream();
+    
+    for _ in 0..50 {
+        let mut chunk = vec![0u8; 8192];
+        stream.read(&mut chunk).await.unwrap();
+        output.extend_from_slice(&chunk);
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+    
+    assert!(output.len() > 100_000); // Au moins 100 KB de FLAC
+}
+```
+
+#### Critères de succès Round 2
+
+- ✅ `decode_aac_stream()` suit le pattern existant (MP3, Ogg, etc.)
+- ✅ Auto-détection AAC/ADTS fonctionne
+- ✅ Transcodage AAC → FLAC streaming opérationnel
+- ✅ Tests unitaires et intégration passent
+- ✅ Documentation complète (doctests, exemples)
+- ✅ Feature flag `aac` pour compilation optionnelle
+
+---
+
+### Round 3 : Intégration dans pmoradiofrance (si Round 2 réussit)
+
+**Objectif** : Remplacer le proxy AAC passthrough par un transcodage FLAC.
+
+#### Modifications
+
+**1. `pmoradiofrance/src/server_ext.rs`**
+
+Remplacer le proxy passthrough par un transcodage :
+
+```rust
+async fn proxy_stream(
+    Path(slug): Path<String>,
+    State(state): State<Arc<RadioFranceServerState>>
+) -> Result<Response, (StatusCode, String)> {
+    let stream_url = state.client.get_stream_url(&slug).await
+        .map_err(|e| (StatusCode::NOT_FOUND, e.to_string()))?;
+    
+    let response = reqwest::get(&stream_url).await
+        .map_err(|e| (StatusCode::BAD_GATEWAY, e.to_string()))?;
+    
+    // Transcoder AAC → FLAC avec pmoflac
+    let transcoded = pmoflac::transcode_to_flac_stream(
+        response.bytes_stream(),
+        pmoflac::TranscodeOptions::default()
+    ).await
+    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+    
+    // Enregistrer connexion active et démarrer metadata refresh
+    // ...
+    
+    // Stream FLAC au lieu d'AAC
+    let mut headers = HeaderMap::new();
+    headers.insert("Content-Type", "audio/flac".parse().unwrap());
+    headers.insert("Cache-Control", "no-cache".parse().unwrap());
+    
+    Ok((headers, Body::from_stream(transcoded.into_stream())).into_response())
+}
+```
+
+**2. `pmoradiofrance/src/playlist.rs`**
+
+Changer le protocol_info pour FLAC :
+
+```rust
+// Avant (AAC)
+protocol_info: "http-get:*:audio/aac:*"
+
+// Après (FLAC)
+protocol_info: "http-get:*:audio/flac:*"
+sample_frequency: Some(info.sample_rate.to_string())
+bits_per_sample: Some("16".to_string())
+```
+
+#### Critères de succès Round 3
+
+- ✅ Radio France sert du FLAC au lieu d'AAC
+- ✅ Uniformité : toutes les sources PMOMusic servent du FLAC
+- ✅ Latence acceptable (<2s) pour le streaming live
+- ✅ CPU raisonnable pour 2-3 streams simultanés sur LAN
+- ✅ Métadonnées volatiles toujours mises à jour
+
+---
+
+## Alternative : fdk-aac (si Symphonia échoue)
+
+Si Symphonia ne fonctionne pas en streaming infini, explorer `fdk-aac` :
+
+### Avantages
+- ✅ Décodeur de référence (meilleure qualité)
+- ✅ Conçu pour le streaming
+- ✅ Utilisé en production (Android, etc.)
+
+### Inconvénients
+- ❌ Dépendance C (compilation complexe)
+- ❌ Licence restrictive (vérifier compatibilité projet)
+
+### Prototype minimal
+
+```rust
+use fdk_aac::dec::{Decoder, DecoderParams};
+
+pub async fn decode_aac_with_fdk<R>(reader: R) -> Result<AacDecodedStream>
+where
+    R: AsyncRead + Unpin + Send + 'static,
+{
+    // Similar pattern to pmoflac MP3 decoder
+    // spawn_blocking pour le décodeur C
+    // ...
+}
+```
+
+---
+
+## Résultats attendus
+
+### Minimum viable (Round 1)
+
+- ✅ Rapport technique sur la faisabilité du streaming AAC avec Symphonia
+- ✅ Prototype fonctionnel (même basique)
+- ✅ Identification des limitations et solutions de contournement
+
+### Objectif complet (Round 1-3)
+
+- ✅ Support AAC/ADTS dans `pmoflac` (feature flag optionnelle)
+- ✅ Transcodage AAC → FLAC streaming opérationnel
+- ✅ Radio France servant du FLAC uniforme
+- ✅ Documentation et tests complets
+
+### En cas d'échec
+
+- ✅ Rapport détaillé des blocages techniques
+- ✅ Recommandations alternatives (fdk-aac, attendre évolution Symphonia, etc.)
+- ✅ Garder le proxy AAC passthrough actuel
+
+---
+
+## Références
+
+### Documentation
+- [Symphonia Getting Started](https://github.com/pdeljanov/Symphonia/blob/master/GETTING_STARTED.md)
+- [AdtsReader API](https://docs.rs/symphonia-codec-aac/latest/symphonia_codec_aac/struct.AdtsReader.html)
+- [ADTS Format Specification](https://wiki.multimedia.cx/index.php/ADTS)
+- [fdk-aac Rust Bindings](https://github.com/haileys/fdk-aac-rs)
+
+### Issues et discussions
+- [Symphonia ReadOnlySource Issue #580](https://github.com/RustAudio/rodio/issues/580)
+- [Symphonia MediaSource Trait](https://docs.rs/symphonia-core/latest/symphonia_core/io/index.html)
+
+### Contexte PMOMusic
+- [Task Radio France](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/ToDiscuss/Construire_pmoradiofrance.md)
+- [Architecture pmoflac](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmoflac/src/lib.rs)

Blackboard/ToDiscuss/config_ext.md

@@ -0,0 +1,17 @@
+**Il faut suivre les instructions générales placées dans le fichier : Blackboard/Rules.md**
+
+Partir des fichiers suivants:
+
+- pmocovers/src/config_ext.rs
+- pmoaudiocache/src/config_ext.rs
+- pmoqobuz/src/config_ext.rs
+- pmocache/src/config_ext.rs
+- pmoconfig/PASSWORD_ENCRYPTION.md
+- pmoupnp/src/config_ext.rs
+- pmoparadise/src/config_ext.rs
+
+réalise une fiche descriptive sur le pattern à réaliser pour implémenter un trait d'extension de PMOConfig (pmoconfig::Config).
+
+Le résultat sera une documentation d'implémentation qui sera placé dans le fichier: `Blackboard/Architecture/pmoconfig_ext.md`
+
+Reste bien focalisé sur l'objectif principal.

Blackboard/ToDiscuss/metadata_RF_cache.md

@@ -0,0 +1,173 @@
+**Tu réaliseras ce travail en appliquant scrupuleusement les règles définies dans [@Rules.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules.md)**
+
+**On ne travaille que dans la Crate PMORadioFrance**
+
+À partir de maintenant, tu ne prends plus en compte ce que tu pensais avant et tu écoutes bien. Et tu construis un plan d'implémentation que je dois valider. Tu arrêtes de prendre des initiatives et de faire des bêtises.
+
+- Tu as des fonctions d'interrogation de l'API Radio France qu'il faut utiliser au minimum. Mais Radio France nous donne des dates d'invalidation des métadonnées. Globalement, on doit gérer une grosse map où les valeurs ont des TTL. 
+- Quand un client demande une donnée du cache, si le TTL est atteint, il commence par utiliser l'API Radio France, modifie le cache, puis la retourne. Dans le cas contraire, il retourne directement la donnée.
+
+A chaque fois qu'il fait un appel de l'API Radio France pour modifier ses valeurs, Le cache émet un événement ou avertit ses abonnés, comme quoi les données d'un slug particulier ont été modifiées. Comme ça tout le monde peut se synchroniser.
+
+Les clients, par exemple la fonction Browse, n'interrogent que le cache qui a forcément des données à jour. Les métadonnées ne sont jamais stockées hors du cache, on se réfère toujours à elles.
+
+Nous devons maintenant considérer le fonctionnement du control point. Celui-ci est capable de s'abonner à une playlist pour suivre ses modifications. Il ne peut pas s'abonner à un item. 
+
+Dans le cas d'une radio, on peut considérer que chaque canal, chaque slug, est en réalité une playlist à un item qu'il faut suivre. Ainsi, le Control Point peut décider de jouer cette playlist en s'abonnant à elle et être tenu au courant des modifications par des événements GENA.
+
+La source Radio France doit donc s'abonner aux événements du Cache. A chaque fois qu'un slug est modifié, elle avertit par un événement Jenna que la playlist à un item qui correspond à ce Slug est modifiée.
+
+Maintenant, il y a le cache des stations. Le cache des stations finalement il ne stock qu'un emboîtement de listes de slug. Ça, normalement, ça ne bouge quasiment pas. On peut dire que une fois par jour, on met à jour ce cache. Les listes de slug ont donc un TTL mais très long. 
+
+A chaque browse, on reconstruit un document didl à partir des métadonnées à jour provenant du cache.
+
+## Round 2
+
+Je repasse sur ton code. Tout est beaucoup beaucoup trop compliqué, trop de structures allambiquées, de trucs qui s'emboîtent dans des trucs. Il faut faire simple. Le mot d'ordre est simple. Nous ne construisons pas une usine à gaz, nous construisons simplement un truc capable de diffuser moins d'une centaine de radios.
+
+### Simplification de la notion de station.
+
+Alors, tu fais une distinction entre radio locale et web radio, c'est une distinction sémantique, mais d'un point de vue informatique y'a pas de différence.
+
+L'unité de base, ça devrait être:
+
+pub struct StationGroup {
+    pub stations: Vec<Station>,
+}
+
+La seule règle metier sémantique est: L'index 0 du vecteur est attribué à la station principale du groupe, par exemple FIP, pour le groupe FIP, si elle existe.
+
+Et du coup, les StationGroups devrait juste être un vecteur de StationGroup
+
+- StationGroups définie le niveau zéro du browse
+- StationGroup définit les différents niveaux 1
+
+Chaque station étant représentée maintenant par une playlist à un item item, Il y a un niveau 2 de browsing qui correspond à l'item de la station.
+
+Donc, Station, StationGroup et StationGroups devrait chacun fournir une méthode retournant un objet PMODidl qui se construit en demandant les métadonnées au cache. Genre:
+
+async pub fn to_didl(caches et server_base_url)
+
+## Simplification du cache
+
+Il faut réfléchir, Finalement, qu'est-ce que l'on a besoin de stocker dans le cache pour être efficace? De quoi remplir les Didl. Donc, à partir des données parsées depuis l'API Radio France, il faut reconstruire une structure simplifiée. contenant juste les données telles qu'on va les utiliser dans le diddle. Idéalement, le cache devrait être capable de fournir le bien d'idoles d'un item. Avec une méthode to_didl(slug) -> Un item de la Crate pmodidl. Tout le reste est superflu. Donc ne doit pas être stocké. Pour calculer la durée correctement, Il nous faut la fin de validité de l'item. Il est donc important de stocker end_time. Normalement, end time est aussi le TTL. Car à la fin de la diffusion de cet item, ça veut dire qu'il faut remettre à jour les métadata, Pour avoir l'item suivant.
+
+## Round 3
+
+### Problèmes identifiés
+
+Point 3 : Le cache des slugs doit être persistant et stocké dans la config comme actuellement. Avec un délai d'une semaine. Le cache des métadonnées reste en mémoire. Les métadonnées changent à chaque émission, il n'y a pas de raison de les stocker de manière persistante.
+
+Du coup, le cache des métadonnées, Pour simplifier la vie des autres structures. devrait s'occuper de cacher les covers dans pmocovers et stocker le PK de l'image dans le cache pour pouvoir construire le didl de l'item. 
+
+En fait, le didl de l'item, Dans notre nouvelle strategie est déjà un didl d'une playlist à un item.
+
+### Architecture cible simplifiée
+
+#### 1. Structures de station (models.rs et playlist.rs)
+
+Je ne comprends pas bien la distinction entre les deux:
+A-t-on vraiment besoin des deux fonctions?
+À quoi sert cette fonction to_container?
+
+```
+// Browse niveau 1: retourne les playlists (containers) pour chaque station du groupe
+    pub async fn to_didl(&self, metadata_cache: &MetadataCache, server_base_url: &str) -> Vec<Container>;
+    
+    // Helper pour construire le container de groupe (sans items, juste la structure)
+    pub fn to_container(&self, server_base_url: Option<&str>) -> Container;
+```
+
+```
+impl CachedMetadata {
+    // Parse depuis LiveResponse + Station + optionnel cover cache
+    #[cfg(feature = "cache")]
+    pub async fn from_live_response(
+        station: &Station,
+        live: &LiveResponse,
+        cover_cache: Option<&Arc<CoverCache>>,
+        server_base_url: Option<&str>,
+    ) -> Result<Self>;
+    
+    pub fn from_live_response_sync(
+        station: &Station,
+        live: &LiveResponse,
+        server_base_url: Option<&str>,
+    ) -> Result<Self>;
+```
+
+C'est quoi exactement la fonction from_live_response_sync ?
+J'ai l'impression que tu surcompliques encore.
+
+```
+pub fn to_didl_item(&self, parent_id: &str) -> Item 
+```
+
+Vu ma remarque précédente: 
+  En fait, le didl de l'item, Dans notre nouvelle strategie est déjà un didl d'une playlist à un item.
+
+Cette fonction devrait juste être un toDiddle et retourner le diddle d'une playlist à un item avec exactement les mêmes métadonnées pour la playlist conteneur et l'item à l'intérieur.
+
+### 3. Cache de stations (intégré dans stateful_client.rs)
+
+Comme je le disais plus haut, ce cache doit être permanent via l'usage de la configuration. Comme c'est le cas actuellement.
+
+## Hiérarchie de browse
+
+**Niveau 1**: Browse d'un groupe
+En fait, si un station groupe ne contient qu'un seul item, C'est à dire qu'il n'y a pas plusieurs sous-radios sous ce groupe. on peut directement retourner la playlist simple qui contient simplement cet item. 
+
+Questions pour validation
+
+1. **Organisation des stations sans webradios**: Faut-il créer un groupe pour chaque station standalone (France Culture, France Inter, etc.) ou les mettre toutes dans un seul groupe "Stations principales"?
+   - En fait, si un station groupe ne contient qu'un seul item, C'est à dire qu'il n'y a pas plusieurs sous-radios sous ce groupe. on peut directement retourner la playlist simple qui contient simplement cet item. Sinon, on retourne un container qui contient les playlists de chacun des items. Cela peut directement être implémenté dans le code de la fonction to Didl du groupe de station.
+
+2. **Cache de métadonnées**: In-memory uniquement (données volatiles avec TTL court)?
+   - Oui, in-memory seulement, TTL basé sur la fin de diffusion de cet item.
+
+3. **Cache de stations**: Rester dans pmoconfig avec TTL 1 jour?
+   - Oui, garder le système actuel, Il me semble que le TTL est d'une semaine actuellement, mais le garder tel qu'il est.
+
+4. **Gestion d'erreur API Radio France down**: Retourner les données expirées avec warning?
+   - **Proposition**: Oui, graceful degradation
+     C'est parfait.
+   
+5. **Migration du code existant**: Faut-il maintenir une compatibilité temporaire ou refactoring complet immédiat?
+   - **Proposition**: Refactoring complet, c'est une simplification profonde
+     C'est parfait.
+
+
+## Round 4
+
+### 2. Groupes de stations (playlist.rs)
+
+```
+impl StationGroups {    
+    // Browse niveau 0: retourne les containers de groupes
+    pub async fn to_didl(&self, metadata_cache: &MetadataCache, server_base_url: &str) -> Vec<Container>;
+}
+```
+
+Pourquoi retourner un vecteur de conteneurs et pas un conteneur qui contient des conteneurs? Ça doit retourner une structure didl La fonction s'appelle to_didl. 
+    
+  Il faut être cohérent. Et **SIMPLE**.
+  
+### 3. Cache de métadonnées (NOUVEAU: metadata_cache.rs)
+
+Il y a actuellement dans le code des règles pour passer des métadonnées Radio France vers des métadonnées UPNP, qui agrège les métadonnées selon certaines règles depuis Radio France pour en faire des métadonnées plus simples mais avec une sémantique correcte pour l'interface utilisateur du côté UPNP. Il ne faut pas abandonner ces règles.
+
+### Hiérarchie de browse
+
+**Niveau 0**: `radiofrance` → containers de groupes  
+- "France Culture" (id: `radiofrance:franceculture`) - playlist directe si groupe à 1 station
+- "FIP" (id: `radiofrance:group:fip`) - container de groupe si plusieurs stations
+- "Radios ICI" (id: `radiofrance:ici`) - container de groupe pour les radios locales --> Je te rappelle qu'il n'y a plus de distinction entre radio locale et autres radios. Ça c'était avant. Donc ICI fonctionne exactement comme FIP.
+
+### Étapes d'implémentation
+
+#### Étape 1: Créer metadata_cache.rs
+1. Définir `CachedMetadata` struct avec tous les champs DIDL
+
+On est d'accord que si tu définis ce type là, ça veut dire que tu supprimes le client Stateful. Sans ça, c'est complètement redondant.
+
+A la fin de cette tâche, tu généreras le nouveau plan dans le fichier de rapport tel que c'est demandé par le fichier de règles [@Rules.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules.md) que tu devras suivre scrupuleusement.

Blackboard/ToDiscuss/music_source.md

@@ -0,0 +1,14 @@
+**Il faut suivre les instructions générales placées dans le fichier : Blackboard/Rules.md**
+
+Partir des fichiers suivants:
+
+- pmoparadise/src/source.rs
+- pmoqobuz/src/source.rs
+- pmosource/README.md
+- pmosource/ARCHITECTURE.md
+
+D'écrire dans un fichier d'architecture L'implémentation d'une nouvelle MusicSource.
+
+Le résultat sera une documentation d'implémentation qui sera placé dans le fichier: `Blackboard/Architecture/music_source.md`
+
+Reste bien focalisé sur l'objectif principal.

Blackboard/ToDiscuss/pmoserver_ext.md

@@ -0,0 +1,21 @@
+**Il faut suivre les instructions générales placées dans le fichier : Blackboard/Rules.md**
+
+Partir des fichiers suivants:
+
+- pmoapp/src/lib.rs
+- pmocontrol/src/pmoserver_ext.rs
+- pmoparadise/src/pmoserver_ext.rs
+- pmoaudiocache/src/lib.rs
+- pmomediaserver/src/paradise_streaming.rs
+
+réalise une fiche descriptive sur le pattern à réaliser pour implémenter un trait d'extension du PMO serveur.
+
+Le résultat sera une documentation d'implémentation qui sera placé dans le fichier: `Blackboard/Architecture/pmoserver_ext.md`
+
+## Round 2
+
+J'ai regardé ton document généré et je trouve que tu t'élargis du sujet central documenter lecture d'une extension PMOserver. Peux-tu te recentrer sur le sujet principal.
+
+## Round 3 
+
+Je trouve que le fait de devoir déclarer et documenter les URL dans OpenAPI / utopia était quelque chose d'important. Remets le.

Blackboard/ToThinkAbout/MusicBoxSource.md

@@ -0,0 +1,515 @@
+**Il faut suivre les instructions générales placées dans le fichier : Blackboard/Rules.md**
+
+# MusicBoxSource : Bibliothèque musicale universelle
+
+Créer une **"boîte à musique"** personnelle : un catalogue unifié de morceaux provenant de n'importe quelle source (Qobuz, URLs, fichiers locaux, Radio Paradise, etc.), avec taxonomie de tags et playlists intelligentes.
+
+---
+
+## 🎯 Vision
+
+### Concept
+
+**MusicBoxSource** est une bibliothèque musicale curatoriale qui permet de :
+- **Collecter** : Ajouter des morceaux depuis n'importe quelle source PMOMusic ou URL
+- **Organiser** : Classifier avec une taxonomie de tags extensible
+- **Requêter** : Créer des playlists statiques et smart playlists (requêtes dynamiques)
+- **Exposer** : Servir via UPnP/DIDL-Lite avec navigation multi-axes
+
+### Différence avec `pmoplaylist`
+
+- **`pmoplaylist`** : Playlists FIFO **éphémères** pour sources live (Radio Paradise)
+- **`pmomusicbox`** : Bibliothèque **persistante** cross-sources avec métadonnées enrichies
+
+---
+
+## 🏛️ Architecture globale
+
+```mermaid
+flowchart TB
+    subgraph Sources[Sources PMOMusic]
+        QOBUZ[pmoqobuz]
+        PARADISE[pmoparadise]
+        LOCAL[pmolocal - à créer]
+        URL[URLs directes]
+    end
+    
+    subgraph Import[Import Layer]
+        IMPORTER[MusicBox Importer]
+        JSPF[pmojspf - Parser playlists]
+        META[pmometadata - Extraction]
+    end
+    
+    subgraph Core[pmomusicbox Core]
+        DB[(SQLite Database)]
+        TAXONOMY[Taxonomie Tags]
+        QUERY[Smart Query Engine]
+    end
+    
+    subgraph Cache[Cache Layer]
+        AUDIO[pmoaudiocache]
+        COVERS[pmocovers]
+    end
+    
+    subgraph Export[Export UPnP]
+        SOURCE[MusicSource Trait]
+        DIDL[DIDL-Lite Generator]
+        BROWSE[Multi-Axis Browser]
+    end
+    
+    Sources --> IMPORTER
+    URL --> IMPORTER
+    JSPF --> IMPORTER
+    META --> IMPORTER
+    
+    IMPORTER --> DB
+    DB --> TAXONOMY
+    DB --> QUERY
+    
+    DB <--> AUDIO
+    DB <--> COVERS
+    
+    DB --> SOURCE
+    TAXONOMY --> BROWSE
+    QUERY --> BROWSE
+    SOURCE --> DIDL
+    BROWSE --> DIDL
+```
+
+---
+
+## 🗄️ Modèle de données (SQLite)
+
+### Tables principales
+
+```mermaid
+erDiagram
+    TAG_CATEGORIES ||--o{ TAGS : contient
+    TAG_CATEGORIES ||--o{ TAG_CATEGORIES : parent
+    TAGS ||--o{ ITEM_TAGS : associe
+    MUSIC_ITEMS ||--o{ ITEM_TAGS : a
+    MUSIC_ITEMS ||--o{ PLAYLIST_ITEMS : dans
+    PLAYLISTS ||--o{ PLAYLIST_ITEMS : contient
+    
+    TAG_CATEGORIES {
+        text id PK "Ex: mood, genre"
+        text name "Nom affiché"
+        text parent_id FK "Hiérarchie"
+        text color "Hex color"
+        text icon "Emoji/icon"
+        int display_order
+    }
+    
+    TAGS {
+        text id PK "Ex: mood:energetic"
+        text category_id FK
+        text name "energetic, chill"
+        text description
+        text color "Override"
+    }
+    
+    MUSIC_ITEMS {
+        text id PK "UUID"
+        text source_type "qobuz, url, local"
+        text source_id "ID source"
+        text original_uri "URI source"
+        text cache_audio_pk FK "pmoaudiocache"
+        text cache_cover_pk FK "pmocovers"
+        text title
+        text artist
+        text album
+        int year
+        int rating "1-5 étoiles"
+        int play_count
+    }
+    
+    ITEM_TAGS {
+        text item_id PK,FK
+        text tag_id PK,FK
+        int added_at
+        text source "user, auto"
+    }
+    
+    PLAYLISTS {
+        text id PK
+        text name
+        bool is_smart
+        text smart_query "JSON"
+    }
+    
+    PLAYLIST_ITEMS {
+        text playlist_id PK,FK
+        text item_id FK
+        int position PK
+    }
+```
+
+### Tables d'association
+
+- **`item_tags`** : Liens items ↔ tags (N:M)
+- **`playlist_items`** : Items dans playlists statiques (position, ordre)
+- **`tag_synonyms`** : Synonymes pour recherche (ex: "jazz" → "swing")
+
+### Index & Recherche
+
+- **Indexes B-tree** : artist, album, genre, year, rating, play_count
+- **FTS5 (Full-Text Search)** : title, artist, album, comment
+- **Triggers** : Maintien des tables FTS en sync avec `music_items`
+
+---
+
+## 🎨 Taxonomie par défaut
+
+Catégories préchargées à l'initialisation :
+
+| Catégorie   | Description                      | Exemples de tags                           |
+|-------------|----------------------------------|--------------------------------------------|
+| **Mood**    | État d'esprit, émotion           | energetic, chill, melancholic, happy       |
+| **Genre**   | Style musical                    | rock, jazz, classical, electronic, metal   |
+| **Era**     | Période, décennie                | 60s, 70s, 80s, 90s, contemporary           |
+| **Occasion**| Contexte d'écoute                | workout, focus, party, driving, sleep      |
+| **Tempo**   | Vitesse                          | slow, medium, fast                         |
+| **Instrument** | Instrument dominant           | piano, guitar, vocal, synthesizer          |
+| **Quality** | Qualité audio                    | lossless, high-res, remastered, live       |
+| **Origin**  | Origine géographique             | usa, uk, france, japan, latin, africa      |
+
+**Extensibilité** : L'utilisateur peut créer ses propres catégories et tags.
+
+---
+
+## 📦 Crates architecture
+
+### 1. **`pmojspf`** - Parser de playlists (utilitaire)
+
+**But** : Parser/écrire différents formats de playlists vers/depuis un format pivot JSPF (JSON).
+
+```
+pmojspf/
+├── model.rs        # Structures JSPF (Playlist, Track, Meta)
+├── reader/
+│   ├── jspf.rs     # JSON natif
+│   ├── xspf.rs     # XML (via quick-xml ou crate xspf)
+│   ├── m3u.rs      # M3U/M3U8 (parsing ligne par ligne)
+│   └── pls.rs      # PLS (format INI-like)
+└── writer.rs       # Export JSPF
+```
+
+**Dépendances** : `serde`, `serde_json`, `quick-xml` (ou `xspf` crate)
+
+**Usage** : Réutilisé par `pmomusicbox` pour import/export
+
+---
+
+### 2. **`pmomusicbox`** - Bibliothèque musicale core
+
+**Responsabilités** :
+- Gestion base SQLite (CRUD items, tags, playlists)
+- Import depuis sources PMO (Qobuz, Paradise, Local, URLs)
+- Smart playlists (query builder + exécution SQL)
+- Implémentation `MusicSource` trait (exposition UPnP)
+- Intégration caches audio/covers
+
+```
+pmomusicbox/
+├── db/
+│   ├── schema.rs       # DDL SQLite + migrations
+│   ├── items.rs        # CRUD music_items
+│   ├── tags.rs         # CRUD tags + taxonomie
+│   ├── playlists.rs    # CRUD playlists statiques
+│   ├── smart.rs        # Smart playlists
+│   └── search.rs       # Full-text search (FTS5)
+│
+├── import/
+│   ├── url.rs          # Import URL directe
+│   ├── source.rs       # Import depuis MusicSource
+│   ├── local.rs        # Import fichiers locaux (via pmometadata)
+│   └── playlist.rs     # Import JSPF/M3U8 (via pmojspf)
+│
+├── export/
+│   └── playlist.rs     # Export playlists (JSPF, M3U8)
+│
+├── query/
+│   ├── builder.rs      # SmartPlaylistQuery (DSL)
+│   └── executor.rs     # Génération + exécution SQL
+│
+├── didl/
+│   └── generator.rs    # Conversion items → DIDL-Lite
+│
+├── source.rs           # Impl MusicSource trait
+├── taxonomy.rs         # Taxonomie par défaut + CRUD
+└── config_ext.rs       # Extension pmoconfig
+```
+
+**Dépendances** :
+- `pmosource`, `pmoaudiocache`, `pmocovers`, `pmodidl`, `pmometadata`
+- `pmojspf` (import/export playlists)
+- `rusqlite` (features: `bundled`, `serde_json`)
+- `uuid`, `serde`, `tokio`, `async-trait`
+
+---
+
+### 3. **`pmolocal`** - Source fichiers locaux (à créer)
+
+**But** : Scanner des répertoires locaux et exposer les fichiers audio via `MusicSource`.
+
+```
+pmolocal/
+├── scanner.rs      # Scan récursif de répertoires
+├── watcher.rs      # Hot reload (notify)
+├── source.rs       # Impl MusicSource
+└── config_ext.rs   # Extension pmoconfig
+```
+
+**Workflow** :
+1. `pmolocal` scanne `/home/user/Music`
+2. `pmomusicbox` importe les items découverts
+3. Tags automatiques basés sur métadonnées (genre, année)
+
+---
+
+## 🔄 Flux d'import
+
+### Import depuis une source PMO (ex: Qobuz)
+
+```mermaid
+sequenceDiagram
+    participant QS as Qobuz Source
+    participant MB as MusicBox Importer
+    participant DB as SQLite DB
+    participant AC as pmoaudiocache
+    participant CC as pmocovers
+    
+    QS->>MB: get_item(object_id)
+    MB->>QS: resolve_uri(object_id)
+    
+    Note over MB: 1. Extraire métadonnées DIDL-Lite<br/>2. Générer UUID
+    
+    MB->>DB: INSERT INTO music_items
+    
+    opt Auto-cache activé
+        MB->>AC: Cache audio
+        MB->>CC: Cache cover
+        AC-->>DB: Retourner cache_audio_pk
+        CC-->>DB: Retourner cache_cover_pk
+    end
+    
+    MB-->>QS: item_id (UUID)
+```
+
+### Import URL directe
+
+```mermaid
+flowchart LR
+    URL[URL simple] --> META["pmometadata<br/>Extraction"]
+    META --> UUID[Générer UUID]
+    UUID --> DB[("music_items")]
+    DB --> CACHE{"Auto-cache?"}
+    CACHE -->|Oui| AC[pmoaudiocache]
+    CACHE -->|Non| END[Fin]
+    AC --> END
+```
+
+### Import playlist JSPF/M3U8
+
+```mermaid
+flowchart LR
+    FILE[Fichier playlist] --> JSPF["pmojspf<br/>Parser"]
+    JSPF --> STRUCT[Structure JSPF]
+    STRUCT --> LOOP{"Pour chaque track"}
+    LOOP --> IMPORT[Import comme URL]
+    IMPORT --> DB[("music_items")]
+    DB --> PLAYLIST[Créer playlist statique]
+    PLAYLIST --> LINK[Lier tracks à playlist]
+```
+
+---
+
+## 🔍 Smart Playlists (Query DSL)
+
+### Concept
+
+Les smart playlists sont des **requêtes sauvegardées** qui génèrent dynamiquement une liste de tracks.
+
+### Structure de requête (JSON)
+
+```json
+{
+  "include_all_tags": ["mood:energetic", "genre:rock"],
+  "exclude_tags": ["mood:melancholic"],
+  "year_min": 1980,
+  "year_max": 1989,
+  "min_rating": 4,
+  "lossless_only": true,
+  "order_by": "play_count",
+  "order": "desc",
+  "limit": 50
+}
+```
+
+### Traduction SQL
+
+```sql
+SELECT * FROM music_items
+WHERE id IN (
+    SELECT item_id FROM item_tags WHERE tag_id IN ('mood:energetic', 'genre:rock')
+    GROUP BY item_id HAVING COUNT(DISTINCT tag_id) = 2  -- ALL tags
+)
+AND id NOT IN (
+    SELECT item_id FROM item_tags WHERE tag_id = 'mood:melancholic'
+)
+AND year BETWEEN 1980 AND 1989
+AND rating >= 4
+AND codec IN ('flac', 'alac')
+ORDER BY play_count DESC
+LIMIT 50;
+```
+
+---
+
+## 🎭 Exposition UPnP (MusicSource)
+
+### Structure de navigation
+
+```mermaid
+graph TB
+    ROOT[musicbox/] --> ARTIST[by-artist/]
+    ROOT --> ALBUM[by-album/]
+    ROOT --> GENRE[by-genre/]
+    ROOT --> TAG[by-tag/]
+    ROOT --> PLAYLISTS[playlists/]
+    ROOT --> SMART[smart-playlists/]
+    ROOT --> FAV[favorites/]
+    ROOT --> RECENT[recent/]
+    
+    ARTIST --> PF[Pink Floyd/]
+    ARTIST --> Q[Queen/]
+    PF --> WALL[The Wall/]
+    PF --> WYWH[Wish You Were Here/]
+    WALL --> ITEM1[Another Brick... 🎵]
+    
+    TAG --> MOOD[mood/]
+    TAG --> OCC[occasion/]
+    TAG --> ERA[era/]
+    
+    MOOD --> ENRG[energetic/]
+    MOOD --> CHILL[chill/]
+    ENRG --> ITEMS1[items taggués 🎵]
+    
+    OCC --> WORK[workout/]
+    OCC --> FOCUS[focus/]
+    
+    ERA --> E80[80s/]
+    ERA --> E90[90s/]
+    
+    PLAYLISTS --> PL1[My Favorites/]
+    PLAYLISTS --> PL2[Summer 2024/]
+    
+    SMART --> SP1[80s Rock Workout/]
+    SMART --> SP2[Jazz Dinner/]
+    
+    style ITEM1 fill:#e1f5ff
+    style ITEMS1 fill:#e1f5ff
+```
+
+### Object IDs
+
+```
+musicbox:by-artist:{artist_name}
+musicbox:by-album:{album_id}
+musicbox:by-tag:{category}:{tag_name}
+musicbox:playlist:{playlist_id}
+musicbox:smart:{smart_playlist_id}
+musicbox:item:{item_id}
+```
+
+---
+
+## 🔌 Intégration avec l'écosystème PMOMusic
+
+### Avec pmoaudiocache
+
+- Import → Déclencher cache automatique (si `auto_cache: true`)
+- `resolve_uri()` → Retourner URI cachée si disponible
+
+### Avec pmocovers
+
+- Import → Télécharger cover art
+- Browse → Inclure `album_art` dans DIDL-Lite
+
+### Avec pmoserver (feature `server`)
+
+- API REST pour manipulation (CRUD items, tags, playlists)
+- SSE pour notifications de changements
+- Endpoints OpenAPI (utoipa)
+
+---
+
+## 📝 Plan d'implémentation (Phases)
+
+### Phase 1 : Fondations
+- Schéma SQLite complet
+- Crate `pmojspf` (parser playlists)
+- CRUD basique dans `pmomusicbox` (items, tags)
+- Taxonomie par défaut
+- Import URL simple
+- Extension pmoconfig
+
+### Phase 2 : Import cross-sources
+- Import depuis MusicSource (Qobuz, Paradise)
+- Import playlists (JSPF/M3U8)
+- Intégration caches (audio, covers)
+- Crate `pmolocal` (fichiers locaux)
+
+### Phase 3 : Smart Playlists
+- Query builder (DSL)
+- Exécuteur SQL
+- CRUD smart playlists
+- Export JSPF
+
+### Phase 4 : MusicSource UPnP
+- Implémentation trait `MusicSource`
+- Génération DIDL-Lite
+- Browse multi-axes (artist, album, tag)
+- Recherche full-text (FTS5)
+
+### Phase 5 : Fonctionnalités avancées
+- Statistiques d'écoute (play_count, last_played)
+- Auto-tagging (genre depuis métadonnées)
+- API REST (feature `server`)
+- Recommandations (items similaires)
+
+---
+
+## 🎯 Cas d'usage
+
+### Workflow typique
+
+1. **Découverte** : Écouter Radio Paradise, tomber sur un morceau génial
+2. **Ajout** : `musicbox.import_from_source(&paradise, "track-123")`
+3. **Organisation** : Ajouter tags `mood:chill`, `occasion:focus`
+4. **Playlist** : Smart playlist "Focus Music" avec requête `mood:chill + occasion:focus`
+5. **Écoute** : Naviguer dans UPnP → `musicbox/smart-playlists/Focus Music/`
+
+### Scénario : Bibliothèque mixte
+
+- Albums Qobuz haute résolution
+- Playlists M3U8 importées depuis iTunes
+- Fichiers FLAC locaux scannés
+- URLs de SoundCloud
+- Tracks Radio Paradise capturés
+
+**Tout unifié dans MusicBox, accessible via UPnP, organisé par tags.**
+
+---
+
+## 📚 Références
+
+### Standards
+- [JSPF Spec](https://www.xspf.org/jspf)
+- [XSPF Spec](https://www.xspf.org/spec)
+- [SQLite FTS5](https://www.sqlite.org/fts5.html)
+
+### Inspirations
+- [Beets](https://beets.io/) - Music library manager
+- [Navidrome](https://www.navidrome.org/) - Music server
+- [MusicBrainz Picard](https://picard.musicbrainz.org/) - Tagger

Blackboard/ToThinkAbout/PlayListSource.md

@@ -0,0 +1,570 @@
+**Il faut suivre les instructions générales placées dans le fichier : Blackboard/Rules.md**
+
+# PlaylistSource : MusicSource pour playlists
+
+Implémenter une source PMOMusic capable de servir un catalogue de playlists hiérarchisé via UPnP.
+
+---
+
+## 📋 Décisions de conception
+
+### Format pivot : JSPF (JSON)
+
+**Choix** : JSPF comme format interne central
+- Métadonnées riches (title, creator, album, annotation, image, duration, etc.)
+- JSON natif avec serde (Rust-friendly)
+- Standard ouvert (Xiph.Org)
+- Extensible via champ `meta`
+
+**Formats supportés** :
+- ✅ **JSPF** (.jspf) - JSON, format natif
+- ✅ **XSPF** (.xspf) - XML, conversion vers JSPF
+- ✅ **M3U8** (.m3u8) - Texte, métadonnées limitées
+- ✅ **PLS** (.pls) - INI-like, très basique
+
+**Architecture** : 1 Writer (JSPF) + 4 Readers (JSPF, XSPF, M3U8, PLS) → Structure JSPF centrale
+
+```mermaid
+flowchart LR
+    JSPF[JSPF JSON] --> JR[JspfReader]
+    XSPF[XSPF XML] --> XR[XspfReader]
+    M3U8[M3U8 Text] --> MR[M3uReader]
+    PLS[PLS INI] --> PR[PlsReader]
+    
+    JR --> CORE[JSPF Structure]
+    XR --> CORE
+    MR --> CORE
+    PR --> CORE
+    
+    CORE --> W[JspfWriter]
+    W --> OUT[.jspf]
+```
+
+---
+
+## 🗂️ Structure du répertoire
+
+```
+playlists/
+├── metadata.json              # Métadonnées du conteneur racine
+├── Jazz/
+│   ├── metadata.json          # Métadonnées catégorie Jazz
+│   ├── standards.jspf
+│   ├── bebop.jspf
+│   └── covers/
+│       └── standards.webp
+├── Classical/
+│   ├── metadata.json
+│   ├── baroque.jspf
+│   └── romantic.jspf
+└── Rock/
+    ├── metadata.json
+    └── 70s.jspf
+```
+
+### Fichier `metadata.json` (conteneur)
+
+```json
+{
+  "container": {
+    "title": "Collection Jazz",
+    "description": "Mes playlists jazz favorites",
+    "creator": "John Doe",
+    "image": "covers/jazz-collection.webp",
+    "date": "2026-01-15",
+    "meta": [
+      {"rel": "genre", "content": "Jazz"},
+      {"rel": "mood", "content": "Relaxing"}
+    ]
+  }
+}
+```
+
+---
+
+## 🏗️ Composants à implémenter
+
+### 1. Crate `pmojspf` (parsing playlists)
+
+**Responsabilité** : Parser différents formats de playlist vers structure JSPF unifiée
+
+#### Structure
+
+```
+pmojspf/
+├── Cargo.toml
+├── src/
+│   ├── lib.rs           # API publique
+│   ├── model.rs         # Structures JSPF
+│   ├── writer.rs        # JspfWriter
+│   ├── reader/
+│   │   ├── mod.rs       # Trait PlaylistReader
+│   │   ├── jspf.rs      # Reader JSON natif (serde_json)
+│   │   ├── xspf.rs      # Reader XML (xml-rs)
+│   │   ├── m3u.rs       # Reader M3U8 (parsing ligne par ligne)
+│   │   └── pls.rs       # Reader PLS (format INI-like)
+│   └── error.rs
+└── tests/
+    └── fixtures/
+```
+
+#### Modèle de données
+
+**Inspiré de la crate [xspf](https://crates.io/crates/xspf) v0.4.2**
+
+```rust
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Jspf {
+    pub playlist: JspfPlaylist,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct JspfPlaylist {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub creator: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub annotation: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub info: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub identifier: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub date: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub license: Option<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub attribution: Vec<JspfAttribution>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub meta: Vec<JspfMeta>,
+    #[serde(default)]
+    pub track: Vec<JspfTrack>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct JspfTrack {
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub location: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub identifier: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub creator: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub annotation: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub info: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub album: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub track_num: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub duration: Option<u64>,  // millisecondes
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub meta: Vec<JspfMeta>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum JspfAttribution {
+    Location { location: String },
+    Identifier { identifier: String },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JspfMeta {
+    pub rel: String,
+    pub content: String,
+}
+```
+
+#### Trait PlaylistReader
+
+```rust
+use std::io::Read;
+
+pub trait PlaylistReader {
+    fn read<R: Read>(reader: R) -> Result<Jspf>;
+    fn from_str(s: &str) -> Result<Jspf>;
+    fn from_file<P: AsRef<Path>>(path: P) -> Result<Jspf>;
+}
+```
+
+#### Implémentations des Readers
+
+##### JspfReader (✅ Simple - serde_json)
+
+```rust
+pub struct JspfReader;
+
+impl PlaylistReader for JspfReader {
+    fn read<R: Read>(reader: R) -> Result<Jspf> {
+        serde_json::from_reader(reader)
+            .map_err(|e| Error::ParseError(format!("JSON: {}", e)))
+    }
+}
+```
+
+**Dépendances** : `serde_json`
+
+##### XspfReader (⚠️ Complexe - xml-rs)
+
+**Approche** : Machine à états XML pour parser `<playlist>`, `<track>`, etc.
+
+**Alternative** : Utiliser la crate `xspf` existante puis convertir → JSPF
+
+```rust
+pub struct XspfReader;
+
+impl PlaylistReader for XspfReader {
+    fn read<R: Read>(reader: R) -> Result<Jspf> {
+        // Parser XML avec EventReader
+        // État : in_playlist, in_track, current_element
+        // Mapping: <title> → playlist.title, <track> → JspfTrack
+    }
+}
+```
+
+**Dépendances** : `xml-rs` ou réutiliser `xspf` crate
+
+##### M3uReader (⚙️ Modéré - ligne par ligne)
+
+**Format** :
+```m3u
+#EXTM3U
+#PLAYLIST:Ma Playlist Jazz
+#EXTINF:284,John Coltrane - Giant Steps
+#EXTART:John Coltrane
+#EXTALB:Giant Steps
+file:///music/coltrane.flac
+```
+
+```rust
+pub struct M3uReader;
+
+impl PlaylistReader for M3uReader {
+    fn read<R: Read>(reader: R) -> Result<Jspf> {
+        // BufReader ligne par ligne
+        // Parser #EXTINF:duration,artist - title
+        // Gérer extensions non-standard (#EXTART, #EXTALB, #EXTIMG)
+    }
+}
+```
+
+**Dépendances** : stdlib uniquement
+
+**Limitations** : Métadonnées pauvres, beaucoup de champs `None`
+
+##### PlsReader (⚙️ Modéré - format INI)
+
+**Format** :
+```ini
+[playlist]
+NumberOfEntries=2
+File1=file:///music/coltrane.flac
+Title1=John Coltrane - Giant Steps
+Length1=284
+```
+
+```rust
+pub struct PlsReader;
+
+impl PlaylistReader for PlsReader {
+    fn read<R: Read>(reader: R) -> Result<Jspf> {
+        // HashMap<index, (file, title, duration)>
+        // Parser FileN=..., TitleN=..., LengthN=...
+        // Trier par index et convertir en JspfTrack
+    }
+}
+```
+
+**Dépendances** : stdlib uniquement
+
+**Limitations** : File, Title, Length seulement
+
+#### JspfWriter
+
+```rust
+pub struct JspfWriter;
+
+impl JspfWriter {
+    pub fn write<W: Write>(jspf: &Jspf, writer: W) -> Result<()>;
+    pub fn write_pretty<W: Write>(jspf: &Jspf, writer: W) -> Result<()>;
+    pub fn to_string(jspf: &Jspf) -> Result<String>;
+    pub fn to_string_pretty(jspf: &Jspf) -> Result<String>;
+}
+```
+
+#### API publique
+
+```rust
+pub use model::{Jspf, JspfPlaylist, JspfTrack, JspfMeta, JspfAttribution};
+pub use reader::{PlaylistReader, JspfReader, XspfReader, M3uReader, PlsReader};
+pub use writer::JspfWriter;
+
+pub enum PlaylistFormat {
+    Jspf,
+    Xspf,
+    M3u8,
+    Pls,
+}
+
+impl PlaylistFormat {
+    pub fn from_extension(ext: &str) -> Option<Self>;
+}
+
+pub fn read_playlist<R: Read>(reader: R, format: PlaylistFormat) -> Result<Jspf>;
+```
+
+---
+
+### 2. Crate `pmoplaylists` (PlaylistSource)
+
+**Responsabilité** : Implémenter `MusicSource` pour servir playlists via UPnP
+
+#### Structures principales
+
+```rust
+pub struct PlaylistSource {
+    root_path: PathBuf,
+    playlists: Arc<RwLock<HashMap<String, ParsedPlaylist>>>,
+    containers: Arc<RwLock<HashMap<PathBuf, ContainerMetadata>>>,
+    watcher: Option<notify::RecommendedWatcher>,
+    base_url: String,
+    update_counter: Arc<RwLock<u32>>,
+    last_change: Arc<RwLock<SystemTime>>,
+}
+
+pub struct ParsedPlaylist {
+    pub metadata: PlaylistMetadata,
+    pub tracks: Vec<PlaylistTrack>,
+    pub source_path: PathBuf,
+    pub format: PlaylistFormat,
+}
+
+pub struct ContainerMetadata {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub creator: Option<String>,
+    pub image: Option<String>,
+    pub date: Option<String>,
+    pub meta: Vec<MetaEntry>,
+}
+
+pub struct ContainerMetadataFile {
+    pub container: ContainerMetadata,
+}
+```
+
+#### Fonctionnalités
+
+1. **Scan hiérarchique** : Parser récursivement dossiers + `metadata.json` + playlists
+2. **Cache** : Éviter re-parsing (playlists + conteneurs)
+3. **Hot reload** : `notify` pour détecter changements
+4. **Browse UPnP** : Générer DIDL-Lite avec métadonnées conteneurs
+5. **Content resolution** : Résoudre URIs via `SourceCacheManager`
+6. **Cover art** : Servir images playlists, tracks, conteneurs
+
+#### Object IDs
+
+```
+playlists                                # Racine
+playlists:category:{path}                # Catégorie (dossier)
+playlists:playlist:{id}                  # Playlist
+playlists:playlist:{id}:track:{index}    # Track dans playlist
+```
+
+#### Gestion `metadata.json`
+
+```rust
+fn load_container_metadata(&self, dir_path: &Path) -> Result<ContainerMetadata> {
+    let metadata_path = dir_path.join("metadata.json");
+    
+    if metadata_path.exists() {
+        let content = fs::read_to_string(&metadata_path)?;
+        let file: ContainerMetadataFile = serde_json::from_str(&content)?;
+        Ok(file.container)
+    } else {
+        // Fallback : nom du répertoire
+        Ok(ContainerMetadata {
+            title: Some(dir_path.file_name()?.to_str()?.to_string()),
+            ..Default::default()
+        })
+    }
+}
+```
+
+---
+
+### 3. Extension pmoconfig
+
+**Fichier** : `pmoplaylists/src/config_ext.rs`
+
+**Pattern** : [pmoconfig_ext.md](../Architecture/pmoconfig_ext.md)
+
+```rust
+use pmoconfig::Config;
+use std::path::{Path, PathBuf};
+
+const DEFAULT_PLAYLISTS_DIR: &str = "playlists";
+
+pub trait PlaylistSourceConfigExt {
+    fn get_playlists_dir(&self) -> PathBuf;
+    fn set_playlists_dir<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()>;
+    fn get_playlists_enabled(&self) -> bool;
+    fn set_playlists_enabled(&self, enabled: bool) -> anyhow::Result<()>;
+    fn get_playlists_supported_formats(&self) -> Vec<String>;
+    fn set_playlists_supported_formats(&self, formats: Vec<String>) -> anyhow::Result<()>;
+}
+
+impl PlaylistSourceConfigExt for Config {
+    fn get_playlists_dir(&self) -> PathBuf {
+        self.get_managed_dir("sources.playlists.directory", DEFAULT_PLAYLISTS_DIR)
+            .expect("Failed to get playlists directory")
+    }
+    
+    fn set_playlists_dir<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
+        self.set_managed_dir("sources.playlists.directory", path)
+    }
+    
+    fn get_playlists_enabled(&self) -> bool {
+        self.get_value("sources.playlists.enabled")
+            .unwrap_or_else(|_| {
+                let _ = self.set_value("sources.playlists.enabled", true);
+                true
+            })
+    }
+    
+    fn set_playlists_enabled(&self, enabled: bool) -> anyhow::Result<()> {
+        self.set_value("sources.playlists.enabled", enabled)
+    }
+    
+    fn get_playlists_supported_formats(&self) -> Vec<String> {
+        self.get_value("sources.playlists.formats")
+            .unwrap_or_else(|_| {
+                let default = vec!["jspf".into(), "xspf".into(), "m3u8".into(), "pls".into()];
+                let _ = self.set_value("sources.playlists.formats", &default);
+                default
+            })
+    }
+    
+    fn set_playlists_supported_formats(&self, formats: Vec<String>) -> anyhow::Result<()> {
+        self.set_value("sources.playlists.formats", formats)
+    }
+}
+```
+
+**Config YAML** :
+
+```yaml
+sources:
+  playlists:
+    enabled: true
+    directory: "playlists"
+    formats:
+      - jspf
+      - xspf
+      - m3u8
+      - pls
+```
+
+**Utilisation** :
+
+```rust
+use pmoconfig::Config;
+use pmoplaylists::config_ext::PlaylistSourceConfigExt;
+
+let config = Config::load()?;
+
+if config.get_playlists_enabled() {
+    let playlists_dir = config.get_playlists_dir();
+    let playlist_source = PlaylistSource::new(playlists_dir, config.clone())?;
+}
+```
+
+---
+
+## 🔌 Intégration MusicBrainz (optionnelle - Phase 2)
+
+### Crate recommandée : `musicbrainz_rs`
+
+[musicbrainz_rs](https://crates.io/crates/musicbrainz_rs) v0.5+
+- Client async/blocking
+- Rate limiting automatique (1 req/sec)
+- Support CoverArt Archive
+- MSRV: Rust 1.71.1
+
+### Cas d'usage
+
+1. **Résolution d'identifiants** :
+   ```json
+   {"identifier": ["musicbrainz://recording/abc123"], "title": null}
+   ```
+   → Récupérer métadonnées depuis MusicBrainz
+
+2. **Enrichissement playlists pauvres** : M3U8/PLS → MusicBrainz → métadonnées complètes
+
+3. **Cover art** : CoverArt Archive
+
+### Configuration
+
+```yaml
+sources:
+  playlists:
+    musicbrainz:
+      enabled: false
+      enrich_metadata: false
+      rate_limit_per_sec: 1
+```
+
+**Stratégie** :
+- **Phase 1 (MVP)** : Ne pas implémenter, stocker identifiants tel quel
+- **Phase 2** : Dépendance optionnelle, service asynchrone, configurable
+
+---
+
+## 📝 Prochaines étapes
+
+1. ✅ Choix format : JSPF central
+2. ✅ Modèle données : Structures JSPF
+3. ✅ Extension pmoconfig : Trait défini
+4. ⏳ **Implémenter `pmojspf`** :
+   - `JspfReader` (serde_json)
+   - `XspfReader` (xml-rs ou crate xspf)
+   - `M3uReader` (parsing ligne par ligne)
+   - `PlsReader` (format INI)
+   - `JspfWriter` (serde_json)
+5. ⏳ **Implémenter `pmoplaylists`** :
+   - `PlaylistSource` (trait `MusicSource`)
+   - Scan hiérarchique + cache
+   - Hot reload (notify)
+   - Browse UPnP (DIDL-Lite)
+   - Gestion `metadata.json`
+6. ⏳ Tests avec clients UPnP
+
+---
+
+## 📚 Sources
+
+### Spécifications
+- [XSPF Spec](https://www.xspf.org/spec)
+- [JSPF Spec](https://www.xspf.org/jspf)
+- [M3U - Wikipedia](https://en.wikipedia.org/wiki/M3U)
+- [PLS - Wikipedia](https://en.wikipedia.org/wiki/PLS_(file_format))
+
+### Crates Rust
+- [xspf](https://crates.io/crates/xspf) - Parser XML XSPF
+- [musicbrainz_rs](https://crates.io/crates/musicbrainz_rs) - API MusicBrainz
+- [MusicBrainz API Docs](https://musicbrainz.org/doc/MusicBrainz_API)

Blackboard/ToThinkAbout/analyse_metadonnees_franceculture.md

@@ -0,0 +1,474 @@
+# Analyse : Récupération des métadonnées France Culture
+
+## Objectif
+Comprendre comment le site web de France Culture (https://www.radiofrance.fr/franceculture) obtient et affiche les informations sur l'émission en cours.
+
+## Architecture du site
+
+### Framework utilisé
+**SvelteKit** avec Server-Side Rendering (SSR)
+
+Le site utilise SvelteKit, comme en témoignent :
+- L'attribut `data-sveltekit-preload-data="hover"` sur le `<body>`
+- Les classes CSS préfixées par `svelte-` (ex: `svelte-1thibul`, `svelte-qz676b`)
+- Les chemins vers les assets : `/client/immutable/assets/`
+
+### Rendu des données
+**SSR (Server-Side Rendering)** - Les données sont déjà présentes dans le HTML initial
+
+## Méthode de récupération des informations
+
+### ✅ API publique JSON découverte !
+
+**Après analyse du trafic réseau (fichier HAR), l'API officielle existe et est OUVERTE :**
+
+#### API LiveMeta (métadonnées en temps réel)
+```
+https://api.radiofrance.fr/livemeta/live/5/transistor_culture_player
+```
+
+**Caractéristiques :**
+- ✅ **Aucune authentification requise** (pas de token)
+- ✅ **Endpoint officiel** utilisé par le site web
+- ✅ **JSON structuré** avec émission en cours, précédente et suivante
+- ✅ **Timestamps précis** de début et fin d'émission
+- ✅ **UUIDs des émissions** pour récupérer plus de détails
+- ✅ **Indicateur de rafraîchissement** (`delayToRefresh` en millisecondes)
+
+**Exemple de réponse :**
+```json
+{
+  "prev": [{
+    "firstLine": "Le direct",
+    "firstLineUuid": null,
+    "firstLinePath": null,
+    "secondLine": "France Culture, l'esprit d'ouverture",
+    "cover": "4e9fba8d-7675-409d-86a0-fce40f0cd4a6",
+    "startTime": null,
+    "endTime": null
+  }],
+  "now": {
+    "firstLine": "La Série fiction",
+    "firstLineUuid": "69cf4362-6bfb-48d1-89cf-9d11202f9938",
+    "firstLineExpressionUuid": "69cf4362-6bfb-48d1-89cf-9d11202f9938",
+    "firstLinePath": "franceculture/podcasts/fictions-le-feuilleton",
+    "firstLinePathUuid": "3c1c2e55-41a0-11e5-9fe0-005056a87c89",
+    "secondLine": "\"Ségou\" de Maryse Condé 9/10 : Deuil et pénitence",
+    "secondLineExpressionUuid": "69cf4362-6bfb-48d1-89cf-9d11202f9938",
+    "cover": "436430f7-5b2b-43f2-9f3c-28f2ad6cae39",
+    "startTime": 1769108400,
+    "endTime": 1769110122
+  },
+  "next": [{
+    "firstLine": "L'Instant poésie",
+    "firstLinePath": "franceculture/podcasts/l-instant-poesie",
+    "firstLineUuid": "06fe22c7-144c-41b8-983d-ec956595b694",
+    "secondLine": "L'Instant poésie d'Abd al Malik 14/20 : \"Roman inachevé\" de Louis Aragon, une main tendue",
+    "cover": "a18a392b-f7d5-41bd-972a-e64451f35213",
+    "startTime": 1769110200,
+    "endTime": 1769110555
+  }],
+  "delayToRefresh": 742000
+}
+```
+
+**Paramètres optionnels :**
+- `?date=<timestamp>` : Récupérer les métadonnées à un moment donné (historique)
+
+#### API Pikapi (images de couverture)
+```
+https://www.radiofrance.fr/pikapi/images/{uuid}/{taille}
+```
+
+**Exemples :**
+- `https://www.radiofrance.fr/pikapi/images/436430f7-5b2b-43f2-9f3c-28f2ad6cae39/200x200`
+- Autres tailles disponibles (à tester)
+
+### Anciennes tentatives (pour référence historique)
+Les tentatives d'accès aux endpoints suivants ont échoué :
+- `https://www.radiofrance.fr/api/v2.1/stations/franceculture` → retourne du HTML
+- `https://www.radiofrance.fr/api/v2.1/stations/franceculture/live` → retourne du HTML
+- `https://openapi.radiofrance.fr/v1/graphql` → nécessite un header `x-token`
+
+### Données embarquées dans le HTML (SSR)
+Les informations sont également directement rendues dans le HTML par le serveur SvelteKit (méthode de fallback).
+
+## Structure HTML des métadonnées
+
+### Zone principale : CoverRadio
+Les informations de l'émission en cours se trouvent dans la section `class="CoverRadio"` :
+
+```html
+<div class="CoverRadio-infoContainer">
+    
+    <!-- Titre de l'émission/segment -->
+    <div class="CoverRadio-title qg-tt3 svelte-1thibul" role="heading" aria-level="1">
+        <span class="truncate qg-focus-container svelte-1t7i9vq">
+            <a href="/franceculture/podcasts/le-journal-de-l-eco/le-jouet-profite-de-la-morosite-ambiante-4949584" 
+               aria-label="Le Journal de l'éco • Le jouet profite de la morosité ambiante">
+                Le Journal de l'éco • Le jouet profite de la morosité ambiante
+            </a>
+        </span>
+    </div>
+    
+    <!-- Nom de l'émission parente + producteur -->
+    <p class="CoverRadio-subtitle qg-tt5 qg-focus-container svelte-1thibul">
+        <a href="/franceculture/podcasts/les-matins">Les Matins</a>
+        <span class="CoverRadio-producer qg-tx1 svelte-qz676b">par Guillaume Erner</span>
+    </p>
+    
+    <!-- Indicateur de direct -->
+    <div class="CoverRadio-ctaTop">
+        <p class="direct qg-st6 CoverRadio-labelDirect dark default svelte-12tsplm">
+            En direct
+        </p>
+    </div>
+    
+</div>
+```
+
+### Classes CSS identifiées
+
+| Classe CSS | Contenu | Utilité |
+|------------|---------|---------|
+| `CoverRadio-title` | Titre du segment/chronique en cours | Titre principal |
+| `CoverRadio-subtitle` | Nom de l'émission parente | Contexte de diffusion |
+| `CoverRadio-producer` | Nom du producteur/animateur | Crédit |
+| `CoverRadio-labelDirect` | Badge "En direct" | Statut de diffusion |
+
+## Stratégies d'extraction
+
+### Option 1 : Scraping HTML simple
+Récupérer la page HTML et extraire les données via :
+- Parsing HTML (BeautifulSoup en Python, scraper en Rust)
+- Regex ciblées sur les classes CSS
+
+**Avantages :**
+- Pas de token nécessaire
+- Données toujours présentes dans le HTML
+- Méthode robuste
+
+**Inconvénients :**
+- Dépendant de la structure HTML
+- Risque de cassure si le site change
+- Parsing HTML plus lourd
+
+### Option 2 : API GraphQL avec token
+L'API GraphQL existe (`https://openapi.radiofrance.fr/v1/graphql`) mais nécessite un `x-token`.
+
+**Étapes :**
+1. Analyser le code JavaScript du site pour trouver comment le token est généré
+2. Extraire ou reproduire la logique de génération de token
+3. Utiliser l'API GraphQL
+
+**Avantages :**
+- API structurée et officielle
+- Données JSON propres
+- Moins de risque de changement
+
+**Inconvénients :**
+- Nécessite un token (non documenté publiquement)
+- Potentiellement bloqué/limité en débit
+- Reverse engineering requis
+
+### Option 3 : API interne SvelteKit
+SvelteKit utilise des endpoints `/__data.json` pour l'hydratation client.
+
+**À explorer :**
+- `https://www.radiofrance.fr/franceculture/__data.json`
+- Endpoints de données internes
+
+## Recommandation
+
+### Pour un projet comme PMOMusic (pmoradiofrance)
+
+**Approche hybride recommandée :**
+
+1. **Court terme : Scraping HTML**
+   - Implémenter un parser HTML en Rust
+   - Cibler les classes CSS `CoverRadio-*`
+   - Parser avec `scraper` ou `select` en Rust
+   
+2. **Moyen terme : Investigation API**
+   - Analyser le code JavaScript pour trouver le token
+   - Tenter d'utiliser l'API GraphQL si possible
+   
+3. **Mise en cache et rafraîchissement**
+   - Rafraîchir les métadonnées toutes les 1-5 minutes
+   - Mettre en cache pour éviter les requêtes excessives
+
+## Exemple de code conceptuel (Rust)
+
+```rust
+use scraper::{Html, Selector};
+
+async fn fetch_current_show() -> Result<ShowInfo, Error> {
+    let html = reqwest::get("https://www.radiofrance.fr/franceculture")
+        .await?
+        .text()
+        .await?;
+    
+    let document = Html::parse_document(&html);
+    
+    // Sélecteurs CSS
+    let title_selector = Selector::parse(".CoverRadio-title a").unwrap();
+    let subtitle_selector = Selector::parse(".CoverRadio-subtitle a").unwrap();
+    let producer_selector = Selector::parse(".CoverRadio-producer").unwrap();
+    
+    let title = document
+        .select(&title_selector)
+        .next()
+        .map(|e| e.inner_html())
+        .unwrap_or_default();
+    
+    let show_name = document
+        .select(&subtitle_selector)
+        .next()
+        .map(|e| e.inner_html())
+        .unwrap_or_default();
+    
+    let producer = document
+        .select(&producer_selector)
+        .next()
+        .map(|e| e.inner_html().replace("par ", ""))
+        .unwrap_or_default();
+    
+    Ok(ShowInfo {
+        title,
+        show_name,
+        producer,
+    })
+}
+```
+
+## Points d'attention
+
+1. **Rate limiting** : Ne pas surcharger le site avec des requêtes trop fréquentes
+2. **User-Agent** : Utiliser un User-Agent identifiable pour un projet open-source
+3. **Gestion d'erreurs** : Le site peut être temporairement indisponible
+4. **Structure HTML** : Peut changer sans préavis
+5. **Respect des CGU** : Vérifier les conditions d'utilisation de Radio France
+
+## Mise à jour de la page côté client
+
+### Comment la page se rafraîchit-elle ?
+
+**Réponse : La page ne se met PAS à jour automatiquement côté client.**
+
+Après analyse :
+1. **Pas de polling/WebSocket** : Aucun mécanisme de `setInterval`, `setTimeout`, WebSocket ou Server-Sent Events (SSE) détecté dans le HTML
+2. **Pas de JavaScript de mise à jour** : Le DOM n'est pas modifié dynamiquement pour les métadonnées `CoverRadio-*`
+3. **Navigation SvelteKit** : Les mises à jour se font via la navigation SPA de SvelteKit
+
+### Mécanisme de navigation SvelteKit
+
+SvelteKit utilise le **preloading** et les **endpoints `__data.json`** :
+
+```
+https://www.radiofrance.fr/franceculture/__data.json
+```
+
+Cet endpoint retourne un **JSON structuré** contenant toutes les données de la page, incluant :
+- Métadonnées de l'émission en cours
+- Configuration du site
+- Contenu de la page
+
+**Format de données** :
+```json
+{
+  "type": "data",
+  "nodes": [
+    {
+      "metadata": { ... },
+      "context": { ... },
+      "mainStationLive": { ... }
+    }
+  ]
+}
+```
+
+### Stratégie de rafraîchissement
+
+Pour un utilisateur sur le site :
+1. **Chargement initial** : SSR complet avec HTML
+2. **Navigation ultérieure** : SvelteKit charge `__data.json` en AJAX
+3. **Rechargement manuel** : L'utilisateur doit recharger la page (F5) pour voir les nouvelles métadonnées
+
+**Il n'y a pas de mise à jour automatique en temps réel.**
+
+## Recommandation mise à jour
+
+### 🏆 Option privilégiée : API LiveMeta officielle (DÉCOUVERTE !)
+
+**URL :** `https://api.radiofrance.fr/livemeta/live/5/transistor_culture_player`
+
+**Avantages :**
+- ✅ **API officielle Radio France** : Endpoint public et documenté
+- ✅ **Aucune authentification** : Pas de token, pas de restriction
+- ✅ **JSON léger et structuré** : Format simple et prévisible
+- ✅ **Données optimales** : Juste ce qu'il faut (prev/now/next)
+- ✅ **Polling intelligent** : `delayToRefresh` indique quand rafraîchir
+- ✅ **Stable** : API de production utilisée par le site officiel
+- ✅ **Support historique** : Paramètre `?date=` pour l'historique
+- ✅ **UUIDs** : Références pour récupérer plus de détails si besoin
+
+**Inconvénients :**
+- Aucun majeur identifié
+
+**Code Rust recommandé :**
+```rust
+use serde::{Deserialize, Serialize};
+use reqwest;
+
+#[derive(Debug, Deserialize, Serialize)]
+struct LiveMetadata {
+    prev: Vec<ShowInfo>,
+    now: ShowInfo,
+    next: Vec<ShowInfo>,
+    #[serde(rename = "delayToRefresh")]
+    delay_to_refresh: u64,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct ShowInfo {
+    #[serde(rename = "firstLine")]
+    first_line: String,
+    #[serde(rename = "firstLineUuid")]
+    first_line_uuid: Option<String>,
+    #[serde(rename = "firstLinePath")]
+    first_line_path: Option<String>,
+    #[serde(rename = "secondLine")]
+    second_line: String,
+    cover: String,
+    #[serde(rename = "startTime")]
+    start_time: Option<u64>,
+    #[serde(rename = "endTime")]
+    end_time: Option<u64>,
+}
+
+async fn fetch_franceculture_live() -> Result<LiveMetadata, reqwest::Error> {
+    let url = "https://api.radiofrance.fr/livemeta/live/5/transistor_culture_player";
+    
+    reqwest::get(url)
+        .await?
+        .json::<LiveMetadata>()
+        .await
+}
+
+// Utilisation avec polling intelligent
+async fn monitor_live() {
+    loop {
+        match fetch_franceculture_live().await {
+            Ok(metadata) => {
+                println!("En cours : {} - {}", 
+                    metadata.now.first_line, 
+                    metadata.now.second_line
+                );
+                
+                // Attendre le temps recommandé avant de rafraîchir
+                tokio::time::sleep(
+                    tokio::time::Duration::from_millis(metadata.delay_to_refresh)
+                ).await;
+            }
+            Err(e) => {
+                eprintln!("Erreur : {}", e);
+                // Fallback : attendre 60 secondes
+                tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
+            }
+        }
+    }
+}
+```
+
+### Hiérarchie des options (mise à jour)
+
+1. **🥇 Premier choix : API LiveMeta** - API officielle Radio France
+2. **🥈 Fallback niveau 1 : `__data.json`** - Endpoint SvelteKit si LiveMeta indisponible
+3. **🥉 Fallback niveau 2 : Scraping HTML** - Si les API JSON sont toutes indisponibles
+4. **💭 Exploration future : API GraphQL** - Si un token public devient disponible
+
+## Conclusion
+
+**Pour la mise à jour côté serveur (PMOMusic) :**
+- ✅ **Utiliser l'API LiveMeta officielle** : `https://api.radiofrance.fr/livemeta/live/5/transistor_culture_player`
+- ✅ **Polling intelligent** : Utiliser `delayToRefresh` pour optimiser les appels
+- ✅ **Récupération des images** : Via Pikapi avec l'UUID de `cover`
+- ✅ **Gestion d'erreur** : Fallback sur `__data.json` puis HTML si nécessaire
+
+**Pour la page web elle-même :**
+- **Aucune mise à jour automatique** : L'utilisateur doit recharger la page manuellement
+- Navigation SPA via SvelteKit charge `__data.json` en AJAX
+- Le SSR initial contient déjà toutes les données dans le HTML
+
+## URLs de flux audio découvertes
+
+### Flux HLS (recommandé)
+
+**Master playlist :**
+```
+https://stream.radiofrance.fr/franceculture/franceculture.m3u8?id=radiofrance
+```
+
+**Qualités disponibles :**
+- **lofi** : 105 kbps (BANDWIDTH=107000) - `franceculture_lofi.m3u8?id=radiofrance`
+- **midfi** : 178 kbps (BANDWIDTH=185000) - `franceculture_midfi.m3u8?id=radiofrance`
+- **hifi** : 268 kbps (BANDWIDTH=280000) - `franceculture_hifi.m3u8?id=radiofrance`
+
+Codec : `mp4a.40.2` (AAC-LC)
+
+### Flux Icecast (à confirmer)
+
+D'après RF_old.json, ces URLs devraient exister (non observées dans le HAR car le player web utilise HLS) :
+
+**MP3 :**
+```
+https://icecast.radiofrance.fr/franceculture-lofi.mp3?id=radiofrance
+https://icecast.radiofrance.fr/franceculture-midfi.mp3?id=radiofrance
+https://icecast.radiofrance.fr/franceculture-hifi.mp3?id=radiofrance
+```
+
+**AAC :**
+```
+https://icecast.radiofrance.fr/franceculture-lofi.aac?id=radiofrance
+https://icecast.radiofrance.fr/franceculture-midfi.aac?id=radiofrance
+https://icecast.radiofrance.fr/franceculture-hifi.aac?id=radiofrance
+```
+
+## Mapping des stations Radio France
+
+D'après l'analyse du fichier HAR et RF_old.json, voici le mapping des IDs de stations :
+
+| Station | ID Station | Endpoint LiveMeta |
+|---------|-----------|-------------------|
+| France Culture | 5 | `/livemeta/live/5/transistor_culture_player` |
+| France Inter | ? | À découvrir |
+| France Musique | ? | À découvrir |
+| FIP | ? | À découvrir |
+| Mouv' | ? | À découvrir |
+| France Bleu (national) | ? | À découvrir |
+
+**Note :** Les IDs des autres stations peuvent être découverts en analysant le HAR de leurs pages respectives ou en testant des valeurs séquentielles (1, 2, 3, 4, 6, 7...).
+
+## Prochaines étapes recommandées
+
+1. ✅ **Implémenter le client LiveMeta** en Rust avec les structures proposées
+2. 🔍 **Découvrir les IDs des autres stations** Radio France
+3. 🔍 **Tester les URLs Icecast** pour confirmer leur disponibilité
+4. 📋 **Documenter l'API complète** dans le code PMOMusic
+5. 🧪 **Tester le paramètre `?date=`** pour l'accès historique
+6. 🎨 **Tester les tailles d'images Pikapi** disponibles (200x200, 400x400, etc.)
+
+## Annexe : Analyse du fichier HAR
+
+**Source :** `www.radiofrance.fr.har`  
+**Date de capture :** 2026-01-22  
+**Page analysée :** https://www.radiofrance.fr/franceculture
+
+**Découvertes principales :**
+- API LiveMeta accessible et ouverte
+- Aucune authentification requise
+- Polling intelligent via `delayToRefresh`
+- Support HLS multi-bitrate
+- API Pikapi pour les images
+
+Cette analyse confirme que Radio France expose des APIs publiques utilisables pour des projets comme PMOMusic.

Blackboard/ToThinkAbout/client_radiofrance_architecture.md

@@ -0,0 +1,831 @@
+# Architecture du client Radio France (client.rs)
+
+**Date** : 2026-01-22  
+**Objectif** : Conception d'une API Rust pour interroger les métadonnées live et flux audio de Radio France  
+**Référence** : Architecture inspirée de `pmoparadise/src/client.rs`
+
+---
+
+## Table des matières
+
+1. [Vue d'ensemble](#vue-densemble)
+2. [Découverte dynamique des stations](#découverte-dynamique-des-stations)
+3. [Architecture du client](#architecture-du-client)
+4. [Structures de données](#structures-de-données)
+5. [Méthodes principales](#méthodes-principales)
+6. [Exemple d'utilisation](#exemple-dutilisation)
+7. [Points d'attention](#points-dattention)
+
+---
+
+## Vue d'ensemble
+
+Le client Radio France doit permettre :
+- **Découverte dynamique** de ~73 stations/webradios (scraping HTML)
+- **Métadonnées live** via `/api/live?` avec polling intelligent
+- **Flux audio** en qualité maximale uniquement (AAC 192 kbps + HLS)
+- **Un seul client** pour toutes les stations (pas un client par station)
+
+### Philosophie
+
+- **Pas de hardcoding** : Toutes les stations sont découvertes dynamiquement
+- **Qualité maximale uniquement** : AAC 192 kbps (hifi) + HLS, pas de choix lofi/midfi
+- **Architecture simple** : Un client unique, les stations sont des paramètres
+
+---
+
+## Découverte dynamique des stations
+
+### Stratégie complète
+
+Radio France n'expose **pas d'API centralisée** listant toutes les stations. La découverte se fait par **scraping HTML** des pages principales :
+
+#### 1. Stations principales (8)
+
+**Source** : `https://www.radiofrance.fr/`
+
+**Méthode** : Scraper le HTML et extraire tous les slugs via regex `(franceinter|franceinfo|franceculture|francemusique|fip|mouv|francebleu|monpetit)`
+
+**Résultat attendu** :
+```
+franceinter
+franceinfo
+franceculture
+francemusique
+fip
+mouv
+francebleu
+monpetitfranceinter
+```
+
+#### 2. Webradios de chaque station (nombre variable)
+
+**Principe** : **TOUTES les stations** peuvent avoir des webradios, pas seulement FIP et France Musique.
+
+**Méthode** : Pour chaque station principale découverte, scraper sa page `https://www.radiofrance.fr/{station}` et extraire les identifiants via regex `{station}_[a-z_]+`
+
+**Exemples découverts** :
+
+**FIP** (`https://www.radiofrance.fr/fip`) :
+```
+fip_cultes
+fip_electro
+fip_groove
+fip_hiphop
+fip_jazz
+fip_metal
+fip_nouveautes
+fip_pop
+fip_reggae
+fip_rock
+fip_sacre_francais
+fip_world
+```
+
+**France Musique** (`https://www.radiofrance.fr/francemusique`) :
+```
+francemusique_baroque
+francemusique_classique_easy
+francemusique_classique_love
+francemusique_classique_plus
+francemusique_concert_rf
+francemusique_evenementielle
+francemusique_la_contemporaine
+francemusique_la_jazz
+francemusique_ocora_monde
+francemusique_opera
+francemusique_piano_zen
+```
+
+**Autres stations** : À découvrir dynamiquement (France Inter, Mouv, etc. pourraient avoir des webradios futures)
+
+#### 3. Radios locales France Bleu (~40)
+
+**Source** : API `/francebleu/api/live?` → champ `localRadios[]`
+
+**Méthode** : Appel API et extraction du tableau JSON
+
+**Exemple de structure** :
+```json
+{
+  "localRadios": [
+    {"id": 12, "title": "ICI Alsace", "name": "francebleu_alsace", "isOnAir": true},
+    {"id": 13, "title": "ICI Armorique", "name": "francebleu_armorique", "isOnAir": true},
+    ...
+  ]
+}
+```
+
+### Total découvert
+
+- **8** stations principales
+- **~23** webradios (12 FIP + 11 France Musique + possibles autres)
+- **~40** radios locales France Bleu
+- **= ~71+ stations au total** (extensible automatiquement si nouvelles webradios)
+
+---
+
+## Architecture du client
+
+### Client unique
+
+Contrairement à une approche "un client par station", nous utilisons **un seul client** avec les stations comme **paramètres de méthode**.
+
+```rust
+pub struct RadioFranceClient {
+    client: reqwest::Client,
+    timeout: Duration,
+}
+```
+
+### Pas de cache interne
+
+Le client est **stateless** et ne cache rien. La gestion du cache (métadonnées, images) sera faite par les couches supérieures (`SourceCacheManager`).
+
+### Builder pattern
+
+Pour permettre la configuration :
+
+```rust
+pub struct ClientBuilder {
+    client: Option<reqwest::Client>,
+    timeout: Duration,
+    user_agent: String,
+}
+```
+
+---
+
+## Structures de données
+
+### 1. Station découverte
+
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Station {
+    pub slug: String,              // "fip_rock", "franceinter"
+    pub name: String,              // "FIP Rock", "France Inter"
+    pub station_type: StationType,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum StationType {
+    Main,                              // Station principale
+    Webradio {                         // Webradio de n'importe quelle station
+        parent_station: String,        // "fip", "francemusique", "mouv", etc.
+    },
+    LocalRadio { region: String },     // Radio locale France Bleu
+}
+```
+
+### 2. Réponse API Live
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LiveResponse {
+    pub station_name: String,
+    pub delay_to_refresh: u64,        // millisecondes
+    pub migrated: bool,
+    pub now: ShowMetadata,
+    pub next: Option<ShowMetadata>,
+    pub local_radios: Option<Vec<LocalRadio>>,  // France Bleu uniquement
+}
+```
+
+### 3. Métadonnées d'émission
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ShowMetadata {
+    pub start_time: Option<u64>,
+    pub end_time: Option<u64>,
+    pub producer: Option<String>,
+    pub first_line: Line,          // Titre émission
+    pub second_line: Line,         // Titre épisode/chronique
+    pub third_line: Option<Line>,  // Sous-titre
+    pub intro: Option<String>,     // Description
+    pub song: Option<Song>,        // Pour radios musicales (FIP, France Musique)
+    pub media: Media,              // Flux audio disponibles
+    pub visual_background: Option<EmbedImage>,
+    pub visuals: Option<Visuals>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Line {
+    pub title: Option<String>,
+    pub id: Option<String>,
+    pub path: Option<String>,
+}
+```
+
+### 4. Morceau musical (FIP, France Musique)
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+pub struct Song {
+    pub id: String,
+    pub year: Option<u32>,
+    pub interpreters: Vec<String>,
+    pub release: Release,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Release {
+    pub label: Option<String>,
+    pub title: Option<String>,
+    pub reference: Option<String>,
+}
+```
+
+### 5. Flux audio
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+pub struct Media {
+    pub sources: Vec<StreamSource>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StreamSource {
+    pub url: String,
+    pub broadcast_type: BroadcastType,
+    pub format: StreamFormat,
+    pub bitrate: u32,
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum BroadcastType {
+    Live,
+    Timeshift,
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum StreamFormat {
+    Mp3,
+    Aac,
+    Hls,
+}
+```
+
+### 6. Images
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EmbedImage {
+    pub model: String,
+    pub src: String,
+    pub width: Option<u32>,
+    pub height: Option<u32>,
+    pub dominant: Option<String>,
+    pub copyright: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Visuals {
+    pub card: Option<EmbedImage>,
+    pub player: Option<EmbedImage>,
+}
+
+pub enum ImageSize {
+    Tiny,      // 88x88
+    Small,     // 200x200
+    Medium,    // 420x720
+    Large,     // 560x960
+    XLarge,    // 1200x680
+    Raw,       // Taille originale
+}
+```
+
+### 7. Radios locales
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LocalRadio {
+    pub id: u32,
+    pub title: String,
+    pub name: String,
+    pub is_on_air: bool,
+}
+```
+
+---
+
+## Méthodes principales
+
+### 1. Création du client
+
+```rust
+impl RadioFranceClient {
+    /// Créer un nouveau client avec settings par défaut
+    pub async fn new() -> Result<Self> {
+        Self::builder().build().await
+    }
+
+    /// Créer un builder pour configuration avancée
+    pub fn builder() -> ClientBuilder {
+        ClientBuilder::default()
+    }
+
+    /// Créer avec un reqwest::Client existant
+    pub fn with_client(client: reqwest::Client) -> Self {
+        Self {
+            client,
+            timeout: Duration::from_secs(30),
+        }
+    }
+}
+```
+
+### 2. Découverte des stations
+
+```rust
+impl RadioFranceClient {
+    /// Découvrir toutes les stations disponibles (scraping + API)
+    pub async fn discover_all_stations(&self) -> Result<Vec<Station>> {
+        let mut stations = Vec::new();
+
+        // 1. Découvrir les stations principales
+        let main_stations = self.scrape_main_stations().await?;
+
+        // 2. Pour CHAQUE station principale, découvrir ses webradios éventuelles
+        for main_station in main_stations {
+            // Ajouter la station principale
+            stations.push(main_station.clone());
+
+            // Découvrir ses webradios (peut retourner 0 si aucune)
+            if let Ok(webradios) = self.scrape_station_webradios(&main_station.slug).await {
+                stations.extend(webradios);
+            }
+        }
+
+        // 3. Cas spécial : radios locales France Bleu (via API)
+        if let Ok(locals) = self.discover_local_radios().await {
+            stations.extend(locals);
+        }
+
+        Ok(stations)
+    }
+
+    /// Scraper les stations principales depuis homepage
+    async fn scrape_main_stations(&self) -> Result<Vec<Station>> {
+        let html = self.client
+            .get("https://www.radiofrance.fr/")
+            .timeout(self.timeout)
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        let re = regex::Regex::new(
+            r"(franceinter|franceinfo|franceculture|francemusique|fip|mouv|francebleu|monpetit)"
+        )?;
+
+        let mut slugs = std::collections::HashSet::new();
+        for cap in re.captures_iter(&html) {
+            slugs.insert(cap[0].to_string());
+        }
+
+        Ok(slugs.into_iter().map(|slug| Station {
+            slug: slug.clone(),
+            name: Self::slug_to_name(&slug),
+            station_type: StationType::Main,
+        }).collect())
+    }
+
+    /// Scraper les webradios d'une station donnée
+    /// 
+    /// Fonctionne pour n'importe quelle station (fip, francemusique, mouv, etc.)
+    /// Retourne un Vec vide si aucune webradio n'est trouvée.
+    async fn scrape_station_webradios(&self, station: &str) -> Result<Vec<Station>> {
+        let url = format!("https://www.radiofrance.fr/{}", station);
+        let html = self.client
+            .get(&url)
+            .timeout(self.timeout)
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        // Pattern générique : {station}_[a-z_]+
+        let pattern = format!(r"{}_[a-z_]+", station);
+        let re = regex::Regex::new(&pattern)?;
+
+        let mut slugs = std::collections::HashSet::new();
+        for cap in re.captures_iter(&html) {
+            slugs.insert(cap[0].to_string());
+        }
+
+        Ok(slugs.into_iter().map(|slug| Station {
+            slug: slug.clone(),
+            name: Self::slug_to_name(&slug),
+            station_type: StationType::Webradio {
+                parent_station: station.to_string(),
+            },
+        }).collect())
+    }
+
+    /// Découvrir les radios locales France Bleu via API
+    async fn discover_local_radios(&self) -> Result<Vec<Station>> {
+        let response = self.live_metadata("francebleu").await?;
+        
+        Ok(response.local_radios
+            .unwrap_or_default()
+            .into_iter()
+            .map(|local| Station {
+                slug: local.name,
+                name: local.title,
+                station_type: StationType::LocalRadio {
+                    region: local.title.replace("ICI ", ""),
+                },
+            })
+            .collect())
+    }
+
+    /// Convertir slug en nom lisible (heuristique simple)
+    fn slug_to_name(slug: &str) -> String {
+        // Transformations basiques, à améliorer
+        slug.replace('_', " ")
+            .split_whitespace()
+            .map(|w| {
+                let mut c = w.chars();
+                match c.next() {
+                    None => String::new(),
+                    Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
+}
+```
+
+### 3. Métadonnées live
+
+```rust
+impl RadioFranceClient {
+    /// Récupérer les métadonnées live d'une station
+    ///
+    /// # Arguments
+    /// * `station` - Slug de la station (ex: "franceculture", "fip_rock")
+    ///
+    /// # Webradios
+    /// Pour les webradios FIP/France Musique, utiliser le format :
+    /// - Principales : "fip", "francemusique"
+    /// - Webradios : "fip_rock", "francemusique_jazz"
+    ///
+    /// L'API utilise le paramètre `?webradio=` automatiquement si nécessaire.
+    pub async fn live_metadata(&self, station: &str) -> Result<LiveResponse> {
+        let (base_station, webradio) = Self::parse_station_slug(station);
+        
+        let mut url = url::Url::parse(&format!(
+            "https://www.radiofrance.fr/{}/api/live?",
+            base_station
+        ))?;
+
+        // Ajouter le paramètre webradio si nécessaire
+        if let Some(wr) = webradio {
+            url.query_pairs_mut().append_pair("webradio", wr);
+        }
+
+        let response = self.client
+            .get(url)
+            .timeout(self.timeout)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(Error::ApiError(format!(
+                "API returned status: {}",
+                response.status()
+            )));
+        }
+
+        Ok(response.json().await?)
+    }
+
+    /// Parser le slug pour extraire station de base et webradio
+    ///
+    /// Exemples :
+    /// - "fip" → ("fip", None)
+    /// - "fip_rock" → ("fip", Some("fip_rock"))
+    /// - "francemusique_jazz" → ("francemusique", Some("francemusique_jazz"))
+    /// - "franceinter" → ("franceinter", None)
+    fn parse_station_slug(slug: &str) -> (&str, Option<&str>) {
+        if slug.starts_with("fip_") {
+            ("fip", Some(slug))
+        } else if slug.starts_with("francemusique_") {
+            ("francemusique", Some(slug))
+        } else if slug.starts_with("francebleu_") {
+            // Radios locales : pas de paramètre webradio, slug direct
+            (slug, None)
+        } else {
+            // Stations principales
+            (slug, None)
+        }
+    }
+
+    /// Récupérer uniquement les métadonnées de l'émission actuelle
+    pub async fn now_playing(&self, station: &str) -> Result<ShowMetadata> {
+        let response = self.live_metadata(station).await?;
+        Ok(response.now)
+    }
+}
+```
+
+### 4. Flux audio (qualité maximale uniquement)
+
+```rust
+impl RadioFranceClient {
+    /// Récupérer l'URL du flux audio en qualité maximale
+    ///
+    /// Priorité : AAC 192 kbps (hifi) > HLS
+    pub async fn get_hifi_stream_url(&self, station: &str) -> Result<String> {
+        let metadata = self.live_metadata(station).await?;
+        
+        // Chercher AAC hifi (192 kbps)
+        if let Some(source) = metadata.now.media.sources.iter().find(|s| {
+            s.format == StreamFormat::Aac 
+            && s.broadcast_type == BroadcastType::Live
+            && s.bitrate == 192
+        }) {
+            return Ok(source.url.clone());
+        }
+
+        // Fallback HLS
+        if let Some(source) = metadata.now.media.sources.iter().find(|s| {
+            s.format == StreamFormat::Hls
+            && s.broadcast_type == BroadcastType::Live
+        }) {
+            return Ok(source.url.clone());
+        }
+
+        Err(Error::NoHifiStream(format!(
+            "No HiFi stream found for station: {}",
+            station
+        )))
+    }
+
+    /// Lister tous les flux disponibles pour une station
+    pub async fn get_available_streams(&self, station: &str) -> Result<Vec<StreamSource>> {
+        let metadata = self.live_metadata(station).await?;
+        Ok(metadata.now.media.sources)
+    }
+}
+```
+
+### 5. Images (Pikapi)
+
+```rust
+impl RadioFranceClient {
+    /// Construire l'URL d'une image Pikapi
+    ///
+    /// # Arguments
+    /// * `uuid` - UUID de l'image (extrait des métadonnées)
+    /// * `size` - Taille souhaitée
+    pub fn get_image_url(uuid: &str, size: ImageSize) -> String {
+        let size_str = match size {
+            ImageSize::Tiny => "88x88",
+            ImageSize::Small => "200x200",
+            ImageSize::Medium => "420x720",
+            ImageSize::Large => "560x960",
+            ImageSize::XLarge => "1200x680",
+            ImageSize::Raw => "raw",
+        };
+
+        format!("https://www.radiofrance.fr/pikapi/images/{}/{}", uuid, size_str)
+    }
+
+    /// Extraire l'UUID d'une URL Pikapi existante
+    pub fn extract_image_uuid(url: &str) -> Option<String> {
+        let re = regex::Regex::new(r"/pikapi/images/([a-f0-9-]+)").ok()?;
+        re.captures(url)
+            .and_then(|cap| cap.get(1))
+            .map(|m| m.as_str().to_string())
+    }
+}
+```
+
+### 6. Polling intelligent
+
+```rust
+impl RadioFranceClient {
+    /// Calculer le délai avant le prochain refresh recommandé
+    pub fn next_refresh_delay(metadata: &LiveResponse) -> Duration {
+        Duration::from_millis(metadata.delay_to_refresh)
+    }
+
+    /// Calculer le délai en tenant compte du temps écoulé
+    pub fn adjusted_refresh_delay(
+        metadata: &LiveResponse,
+        fetched_at: std::time::SystemTime,
+    ) -> Duration {
+        let base_delay = Duration::from_millis(metadata.delay_to_refresh);
+        let elapsed = fetched_at.elapsed().unwrap_or(Duration::ZERO);
+        
+        base_delay.saturating_sub(elapsed)
+    }
+}
+```
+
+---
+
+## Exemple d'utilisation
+
+### Découverte et affichage de toutes les stations
+
+```rust
+use pmoradiofrance::RadioFranceClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = RadioFranceClient::new().await?;
+
+    println!("Découverte des stations...");
+    let stations = client.discover_all_stations().await?;
+
+    println!("Trouvé {} stations :", stations.len());
+    for station in &stations {
+        println!("  - {} ({})", station.name, station.slug);
+    }
+
+    Ok(())
+}
+```
+
+### Récupération des métadonnées live
+
+```rust
+use pmoradiofrance::RadioFranceClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = RadioFranceClient::new().await?;
+
+    // Station principale
+    let fc_live = client.live_metadata("franceculture").await?;
+    println!("France Culture : {} - {}",
+        fc_live.now.first_line.title.unwrap_or_default(),
+        fc_live.now.second_line.title.unwrap_or_default()
+    );
+
+    // Webradio FIP
+    let fip_rock_live = client.live_metadata("fip_rock").await?;
+    if let Some(song) = &fip_rock_live.now.song {
+        println!("FIP Rock : {} - {}",
+            song.interpreters.join(", "),
+            fip_rock_live.now.first_line.title.unwrap_or_default()
+        );
+    }
+
+    Ok(())
+}
+```
+
+### Polling avec délai intelligent
+
+```rust
+use pmoradiofrance::RadioFranceClient;
+use std::time::{Duration, SystemTime};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = RadioFranceClient::new().await?;
+
+    loop {
+        let fetched_at = SystemTime::now();
+        let metadata = client.live_metadata("fip").await?;
+
+        println!("Now: {} - {}",
+            metadata.now.second_line.title.unwrap_or_default(),
+            metadata.now.first_line.title.unwrap_or_default()
+        );
+
+        // Attendre le délai recommandé
+        let delay = RadioFranceClient::adjusted_refresh_delay(&metadata, fetched_at);
+        tokio::time::sleep(delay).await;
+    }
+}
+```
+
+### Récupération du flux HiFi
+
+```rust
+use pmoradiofrance::RadioFranceClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = RadioFranceClient::new().await?;
+
+    let stream_url = client.get_hifi_stream_url("franceculture").await?;
+    println!("Stream HiFi : {}", stream_url);
+    // Exemple : https://icecast.radiofrance.fr/franceculture-hifi.aac?id=radiofrance
+
+    Ok(())
+}
+```
+
+---
+
+## Points d'attention
+
+### 1. Rate limiting
+
+- Pas de limite documentée observée
+- **Toujours** respecter `delayToRefresh` pour éviter les requêtes inutiles
+- Mettre en cache les résultats de `discover_all_stations()` (TTL : 24h recommandé)
+
+### 2. User-Agent
+
+Pour un projet open-source, utiliser un User-Agent identifiable :
+
+```rust
+impl Default for ClientBuilder {
+    fn default() -> Self {
+        Self {
+            user_agent: "PMOMusic/0.3.10 (https://github.com/votre-repo)".to_string(),
+            // ...
+        }
+    }
+}
+```
+
+### 3. Gestion d'erreurs
+
+Les APIs peuvent retourner :
+- **Données vides** (`null`) pour certains champs
+- **`song`** absent pour radios non-musicales (France Inter, France Info, France Culture)
+- **`localRadios`** uniquement pour France Bleu
+- **`visual_background`** parfois absent
+
+Toujours utiliser `Option<>` et gérer les cas manquants.
+
+### 4. Webradios et paramètre `?webradio=`
+
+- **Stations principales** : `/franceinter/api/live?`
+- **Webradios FIP** : `/fip/api/live?webradio=fip_rock`
+- **Webradios France Musique** : `/francemusique/api/live?webradio=francemusique_jazz`
+- **Radios locales** : `/francebleu_alsace/api/live?` (slug direct, pas de paramètre)
+
+### 5. Images Pikapi
+
+Les URLs dans les réponses API utilisent parfois des chemins complets, parfois juste l'UUID :
+
+```json
+"src": "https://www.radiofrance.fr/pikapi/images/436430f7-5b2b-43f2-9f3c-28f2ad6cae39"
+```
+
+Toujours normaliser en extrayant l'UUID et en reconstruisant l'URL avec la taille souhaitée.
+
+### 6. Scraping HTML
+
+Le scraping HTML est **fragile** par nature. Recommandations :
+
+- **Cache agressif** : Stocker les résultats de découverte (TTL 24h minimum)
+- **Fallback** : Avoir une liste de base hardcodée si le scraping échoue
+- **Validation optionnelle** : Tester chaque station découverte avec `/api/live?` avant de l'ajouter (peut être lent)
+- **Monitoring** : Logger les échecs de découverte
+
+### 7. Performance
+
+Pour découvrir ~70 stations :
+- **Scraping** : 1 homepage + 8 pages stations (une par station principale)
+- **Validation France Bleu** : 1 requête API
+- **Total** : ~10 requêtes HTTP
+
+Temps estimé : 3-5 secondes avec timeout 30s (parallélisable pour réduire à ~1-2s).
+
+### 8. Respect des CGU
+
+- APIs publiques utilisées par le site officiel
+- Usage acceptable pour un projet open-source personnel/non-commercial
+- **Ne pas redistribuer** les flux audio commercialement
+- **Ne pas surcharger** les serveurs (respecter `delayToRefresh`)
+
+---
+
+## Prochaines étapes
+
+1. **Implémenter `client.rs`** avec l'architecture décrite
+2. **Ajouter les tests** :
+   - Tests unitaires pour parsing de slugs
+   - Tests d'intégration pour découverte
+   - Tests d'API live (avec captures VCR)
+3. **Intégrer avec `pmosource`** :
+   - Implémenter le trait `MusicSource`
+   - Gérer le cache via `SourceCacheManager`
+   - Support FIFO pour radios musicales (FIP)
+4. **Documenter les limitations** :
+   - Stations non accessibles
+   - Cas d'erreur connus
+   - Métriques de fiabilité
+
+---
+
+**Fin du rapport d'architecture client.rs**

Blackboard/ToThinkAbout/webrenderer.md

@@ -0,0 +1,443 @@
+# Web Media Renderer - Architecture
+
+## Vision
+
+Système de Media Renderer pilotable à distance via UPnP, exposant un flux audio vers différents types de lecteurs physiques.
+
+## Architecture globale en 4 parties
+
+```mermaid
+flowchart LR
+    A[Media Server] -->|flux audio| B[Control Point]
+    B -->|commandes| C[Web Media Renderer]
+    C -->|flux + contrôles| D[Device physique]
+    
+    subgraph Devices physiques
+    D1[Browser]
+    D2[Android Auto]
+    D3[Apple CarPlay]
+    D4[Sonos multipoint]
+    D5[Chromecast]
+    end
+    
+    D --> D1
+    D --> D2
+    D --> D3
+    D --> D4
+    D --> D5
+```
+
+### Rôles
+
+1. **Media Server** - Source audio (le flux OGG-FLAC existant)
+2. **Control Point** - Interface UI qui envoie les commandes (pause, play, seek, next, prev)
+3. **Web Media Renderer** - Hub qui expose le flux et traduit les commandes selon le device
+4. **Physical Device** - Lecteur final (browser, voiture, Sonos, Chromecast...)
+
+## Web Media Renderer - Rôle central
+
+```mermaid
+blockdiag
+{
+    block = Commandes UPnP
+    block -> "Web Media Renderer" -> Adaptation selon device
+    "Web Media Renderer" -> Device-specific protocols
+}
+```
+
+### Rôle central: Adaptateur
+
+Le Web Media Renderer est un **adaptateur** qui:
+- **Reçoit le flux** du Media Server (OGG-FLAC)
+- **Reçoit les commandes** du Control Point (UPnP)
+- **Les traduit** vers les devices physiques
+- **Expose une API de contrôle** commune
+
+### Ce qui est COMMUN (factorisé)
+
+| Layer | Description |
+|-------|-------------|
+| **API contrôle** | pause, resume, seek, next, prev, flush, stop |
+| **Métadonnées** | /nowplaying, /metadata, /state |
+| **Flux audio** | OGG-FLAC (identique pour tous) |
+| **StreamType** | Continuous vs Finite |
+
+### Ce qui est SPÉCIFIQUE (par device)
+
+| Device | Transport | Buffer Management | Sync |
+|--------|-----------|-------------------|------|
+| Browser | HTTP/WebSocket | JS flush | N/A |
+| Android Auto | AA API | native | varies |
+| CarPlay | CP API | native | varies |
+| Sonos | UPnP | none | UPnP |
+| Chromecast | Cast API | none | Cast |
+
+### Problème du buffer (Browser)
+
+Le browser buffer cause des delais de reaction:
+- **Pause**: delai de 5 secondes
+- **Seek**: cherche dans le buffer, pas dans le nouveau flux
+- **Next/Prev**: changement reporte
+
+**Solutions**:
+1. Web Audio API - `audioContext.suspend()/resume()` - plus petit buffer (~50ms)
+2. Frontend flush buffer
+3. Chaque client manage son propre buffer, Web Media Renderer juste expose API
+
+## Implémentation actuelle
+
+### Faits
+
+- Flux audio OGG-FLAC ✓
+- Pause/Resume ✓ (via `OggFlacStreamHandle`)
+- TrackBoundary pour OGG segments
+- StreamType (Continuous vs Finite)
+
+### À faire
+
+- seek/next/prev API
+- WebSocket pour temps réel
+- Metadata endpoint (/nowplaying JSON)
+- MPV integration (multi-point/multi-room)
+
+## Code actuel - Pause/Resume
+
+```rust
+// OggFlacStreamHandle - méthodes de contrôle
+pub fn pause(&self) {
+    self.inner.is_paused.store(true, Ordering::SeqCst);
+}
+
+pub fn resume(&self) {
+    self.inner.is_paused.store(false, Ordering::SeqCst);
+}
+
+pub fn is_paused(&self) -> bool {
+    self.inner.is_paused.load(Ordering::SeqCst)
+}
+```
+
+### Différences Continuous vs Finite
+
+- **Continuous** (radio): pause -> sends silence, drops incoming chunks
+- **Finite** (tracks): pause -> don't receive chunks (backpressure), loops sending silence
+
+## Schéma d'intégration
+
+```mermaid
+sequenceDiagram
+    participant CP as Control Point
+    participant WMR as Web Media Renderer
+    participant FS as Flux Server
+    participant D as Device
+    
+    CP->>WMR: pause()
+    WMR->>FS: commande pause
+    FS->>FS: pause state change
+    FS->>WMR: silence (continuous) / blocked (finite)
+    WMR->>D: flux avec silence
+    D-->>CP: audio joué (avec delay si buffer)
+```
+
+## Le Web Media Renderer - Adaptateur
+
+Le rôle central du Web Media Renderer est de **convertir des ordres UPnP en actions spécifiques** selon le device cible:
+
+```
+UPnP orders → [Web Media Renderer] → Device-specific actions
+```
+
+## Browser Player - Composant web invisible
+
+Pour s'entraîner, on peut se focaliser sur un composant web qui:
+- Est **complètement invisible** (pas de UI)
+- Est **télécommandable** par le Web Media Renderer
+- Joue la musique dans le navigateur
+
+### Specifications
+
+| Requirement | Description |
+|-------------|-------------|
+| Invisible | Pas de UI, pas de controls, pas de visuel |
+| Remote control | Reçoit commandes via WebSocket/HTTP |
+| Auto-reconnect | Reconnection si stream coupé |
+| Buffer management | Flush commandée |
+| Audio format | OGG-FLAC stream |
+
+### Architecture en 2 parties
+
+| Partie | Langage | Rôle |
+|--------|---------|------|
+| Backend | Rust (pmoaudio-ext) | Contrôle, flux OGG-FLAC |
+| Frontend | JavaScript | Player invisible dans le browser |
+
+#### Backend (Rust)
+
+- Expose le flux audio (`/stream`)
+- API contrôle (`/pause`, `/resume`, `/seek`, `/flush`, `/stop`)
+- WebSocket pour temps réel (`/ws`)
+- **Reçoit les rapports de position/state**
+
+```rust
+// Endpoints existants
+POST /pause
+POST /resume  
+POST /seek?t={timestamp}
+POST /flush
+POST /stop
+
+// Stream
+GET /stream
+
+// WebSocket messages REÇUS du player:
+{
+    "type": "position",
+    "position_sec": 125.5,
+    "duration_sec": 240.0,
+    "state": "playing"
+}
+{
+    "type": "track",
+    "id": "...",
+    "title": "...",
+    "artist": "..."
+}
+{
+    "type": "ready_state",
+    "ready_state": "canplay"
+}
+```
+
+#### Frontend (JavaScript)
+
+Composant minimal (~100 lignes):
+
+```javascript
+class RemotePlayer {
+    constructor(wsUrl) {
+        this.ws = new WebSocket(wsUrl);
+        this.audio = new Audio();
+        this.ac = new AudioContext();
+        
+        this.ws.onmessage = (e) => this.handle(e.data);
+    }
+    
+    handle(msg) {
+        switch(msg.type) {
+            case 'stream': this.load(msg.url); break;
+            case 'play': this.play(); break;
+            case 'pause': this.pause(); break;
+            case 'seek': this.seek(msg.timestamp); break;
+            case 'flush': this.flush(); break;
+            case 'stop': this.stop(); break;
+        }
+    }
+    
+    load(url) {
+        this.audio.src = url;
+    }
+    
+    play() {
+        this.audio.play();
+    }
+    
+    pause() {
+        this.audio.pause();
+    }
+    
+    seek(ts) {
+        this.audio.currentTime = ts;
+    }
+    
+    flush() {
+        // Flush buffer immediatement
+        this.audio.pause();
+        this.audio.currentTime = 0;
+        this.audio.src = '';
+        this.ac.suspend();
+    }
+    
+    stop() {
+        this.flush();
+    }
+}
+```
+
+**Usage:**
+
+```html
+<script src="pmo-player.js"></script>
+<script>
+    const player = new PMOPlayer('ws://localhost:8080/ws');
+</script>
+```
+
+### Fichier à créer
+
+`pmoapp/webapp/src/services/PMOPlayer.ts`
+
+### Endpoints HTTP
+
+| Endpoint | Methode | Description |
+|----------|---------|-------------|
+| `/api/webrenderer/register` | POST | Enregistre instance |
+| `/api/webrenderer/{id}/stream` | GET | Flux audio OGG-FLAC |
+| `/api/webrenderer/{id}/position` | POST | Rapporte position |
+| `/api/webrenderer/{id}/report` | POST | Rapporte etat player |
+| `/api/webrenderer/{id}/command` | GET | Recupere commande pending |
+| `/api/webrenderer/{id}` | DELETE | Desenregistre |
+
+### Architecture
+
+```
+Player (Browser) <--HTTP--> Backend
+  - Report: position/state via POST /report
+  - Poll: command via GET /command (500ms)
+  - Stream: GET /stream
+```
+
+### Réactivité
+
+Pour maximiser la réactivité:
+
+| Technique | Impact |
+|-----------|--------|
+| WebSocket | Temps réel vs HTTP polling |
+| AudioContext.suspend() | Buffer ~50ms au lieu de ~5s |
+| Flush command | Vide le buffer immediatement |
+| Native HTML5 audio | Le plus simple = le plus stable |
+
+### Schéma
+
+```mermaid
+sequenceDiagram
+    participant WMR as Web Media Renderer
+    participant BP as Browser Player
+    
+    WMR->>BP: stream(url)
+    BP->>BP: audio.src = url; play()
+    
+    WMR->>BP: pause()
+    BP->>BP: audio.pause()
+    
+    WMR->>BP: seek(timestamp)
+    BP->>BP: audio.currentTime = timestamp
+    
+    WMR->>BP: flush()
+    BP->>BP: audioContext.suspend()
+```
+
+### Mapping orders → actions par device
+
+| UPnP order | Browser | Android Auto | CarPlay | Sonos | Chromecast |
+|-----------|---------|-------------|--------|------|-------------|
+| Play | `audio.play()` | AA play | CP play | UPnP Play | Cast play |
+| Pause | `audio.pause()` | AA pause | CP pause | UPnP Pause | Cast pause |
+| Resume | `audio.play()` | AA play | CP play | UPnP Play | Cast play |
+| Seek | `audio.currentTime=t` | AA seek | CP seek | UPnP Seek | Cast seek |
+| Next | fetch new stream | AA next | CP next | UPnP Next | Cast next |
+| Prev | fetch new stream | AA prev | CP prev | UPnP Prev | Cast prev |
+| Flush | JS `audioContext.suspend()` | AA flush | CP flush | N/A | Cast load |
+| Stop | `audio.stop()` | AA stop | CP stop | UPnP Stop | Cast stop |
+
+### Protocole de contrôle
+
+Le Web Media Renderer expose une API de contrôle uniforme qui est traduite selon le device:
+
+### Commandes
+
+| Commande | Description |
+|---------|-------------|
+| `play` | Lecture |
+| `pause` | Pause (silence ou backpressure) |
+| `resume` | Reprise |
+| `seek(t)` | Seek vers timestamp t |
+| `next` | Track suivante |
+| `prev` | Track précédente |
+| `flush` | **Flush buffer** - ordre critique pour reponse rapide |
+| `stop` | Arrêt total |
+
+### Métadonnées
+
+| Endpoint | Description |
+|----------|-------------|
+| `/nowplaying` | Track actuelle, timestamp, is_paused |
+| `/metadata` | TITLE, ARTIST, ALBUM, COVER |
+| `/state` | État complet (position, duration, volume...) |
+
+### Ordres spéciaux pour devices avec buffer
+
+Pour les devices типа Android Auto, CarPlay, Browser:
+- `flush` = vide le buffer immédiatement
+- `stop` = arrête + flush
+- Ces ordres doivent être traités en priorité
+
+```mermaid
+sequenceDiagram
+    participant CP as Control Point
+    participant WMR as Web Media Renderer
+    participant D as Device (Android Auto, Browser...)
+    
+    CP->>WMR: flush()
+    Note over WMR: Priorité haute - immédiat
+    WMR->>D: FLUSH order
+    D-->>WMR: ack
+    WMR-->>CP: flushed
+    
+    CP->>WMR: pause()
+    Note over WMR: Standard
+    WMR->>D: flux with silence
+```
+
+## multipoint/multi-room
+
+```mermaid
+flowchart TB
+    WMR[Web Media Renderer] -->|flux| R1[Renderer 1]
+    WMR -->|flux| R2[Renderer 2]
+    WMR -->|flux| R3[Renderer N]
+    
+    R1 -->|sync| R2
+    R2 -->|sync| R3
+```
+
+Possibilités:
+- UPnP pour renderers UPnP
+- Cast API pour Chromecast
+- Serveur temps réel pour sync
+
+## Notes techniques
+
+### AudioChunk::silence()
+
+```rust
+impl AudioChunk {
+    pub fn silence(frames: usize, sample_rate: u32) -> Self {
+        AudioChunk::I32(AudioChunkData::<i32>::silence(frames, sample_rate))
+    }
+}
+
+impl<T: Sample> AudioChunkData<T> {
+    pub fn silence(frames: usize, sample_rate: u32) -> Arc<Self> {
+        Self::new(vec![[T::ZERO; 2]; frames], sample_rate, 0.0)
+    }
+}
+```
+
+### StreamType
+
+```rust
+pub enum StreamType {
+    Continuous,  // radio - silence pendant pause
+    Finite,       // tracks - backpressure pendant pause
+}
+```
+
+### TrackBoundary avec StreamType
+
+```rust
+SyncMarker::TrackBoundary { 
+    metadata: ..., 
+    stream_type: StreamType 
+}
+```

Blackboard/ToThinkAbout/webrenderer_server_side_streaming.md

@@ -0,0 +1,202 @@
+# WebRenderer : Streaming Audio Côté Serveur
+
+## Problème actuel
+
+Le webrenderer actuel délègue la lecture audio au navigateur : le serveur envoie une URL
+de fichier via WebSocket (`SetUri`), et le navigateur charge cette URL dans un élément
+`<audio>`. Cette approche a plusieurs limitations :
+
+- Les URLs sont internes (IP locale + port) → inaccessibles depuis l'extérieur
+- Les fichiers sur partage Samba ont des chemins locaux → jamais accessibles au navigateur
+- La `base_url` doit être configurée statiquement → pas de solution propre local/externe
+
+## Solution proposée : flux HTTP serveur
+
+Le serveur génère un flux audio continu par instance de webrenderer, servi sur un endpoint
+HTTP dédié. Le navigateur n'écoute que ce flux — une URL fixe, toujours accessible.
+
+```
+Avant :  ControlPoint → SetAVTransportURI(url_interne) → WebSocket → Browser(<audio src=url_interne>)
+Après :  ControlPoint → SetAVTransportURI(url_interne) → Serveur(ouvre+stream) → Browser(<audio src=/api/webrenderer/{id}/stream>)
+```
+
+## Architecture cible
+
+### Cycle de vie d'une instance
+
+```
+1. Navigateur ouvre la page
+       ↓
+2. POST /api/webrenderer/register  {instance_id, user_agent}
+       ↓
+3. Serveur crée le device UPnP + pipeline audio
+   Annonce SSDP → ControlPoints découvrent le renderer
+   Répond : { stream_url }
+       ↓
+4. Navigateur ouvre GET /api/webrenderer/{id}/stream  (flux FLAC)
+       ↓
+5. ControlPoint → SetAVTransportURI + Play → pipeline démarre
+   Navigateur écoute le flux FLAC en continu
+   SSE global existant → métadonnées et état vers l'interface
+       ↓
+6. Navigateur ferme la page → flux FLAC se coupe
+   Serveur détecte → SSDP byebye → pipeline stoppé
+   Device UPnP retiré
+```
+
+Le lecteur web est complètement invisible — l'interface est pilotée par le SSE global
+existant du ControlPoint. Le WebSocket est supprimé. Pas de SSE dédié au webrenderer.
+
+### Endpoints HTTP
+
+```
+POST /api/webrenderer/register
+     Body: { instance_id, user_agent }
+     Réponse: { stream_url }
+
+GET  /api/webrenderer/{id}/stream
+     Content-Type: audio/flac
+     Cache-Control: no-store, no-transform
+     [Flux FLAC continu — déconnexion = fin de session]
+
+DELETE /api/webrenderer/{id}
+     Désenregistrement explicite (optionnel, fallback sur coupure du flux)
+```
+
+La `stream_url` est une URL relative (`/api/webrenderer/{id}/stream`) — le navigateur
+la résout lui-même, toujours correcte en local et via proxy externe, sans reconstruction
+depuis les headers `X-Forwarded-*`.
+
+### Composants nécessaires
+
+#### 1. Pipeline audio par instance
+
+Chaque instance possède :
+
+- Un **`StreamingFlacSink`** — infrastructure existante dans `pmoaudio-ext`
+- Un **`StreamHandle`** — exposé via l'endpoint `/stream`
+- Un canal de contrôle **`PipelineControl`** — alimenté par les actions UPnP
+
+Le pipeline est créé au `POST /register` et détruit à la coupure du flux FLAC.
+
+#### 2. Enregistrement et création du device UPnP
+
+```
+POST /api/webrenderer/register
+  → créer DeviceInstance UPnP (même factory qu'aujourd'hui)
+  → annoncer via SSDP (nouveau : aujourd'hui pas de SSDP pour le webrenderer)
+  → créer StreamingFlacSink + pipeline
+  → enregistrer dans le RendererRegistry
+  → retourner stream_url
+```
+
+L'`instance_id` vient du `localStorage` du navigateur — stable entre les reloads,
+garantit que le même renderer UPnP est retrouvé à la reconnexion.
+
+#### 3. Modification de `SetAVTransportURI`
+
+Au lieu d'envoyer l'URL au navigateur, le handler UPnP :
+
+1. Reçoit l'URI source (fichier cache, Samba, URL externe...)
+2. Envoie `PipelineControl::LoadUri(uri)` au pipeline de l'instance
+3. Le pipeline ouvre la source côté serveur et alimente le `StreamingFlacSink`
+4. Le navigateur reçoit un event SSE `state_changed: Transitioning` puis `Playing`
+
+#### 4. Gestion des transitions (gapless)
+
+Le `StreamingFlacSink` diffuse un flux FLAC continu. À la frontière de piste, le pipeline
+enchaîne les sources sans interruption du flux HTTP.
+
+`SetNextAVTransportURI` → `PipelineControl::LoadNextUri(uri)` → pré-chargé dans le pipeline
+→ transition seamless, le navigateur ne recharge pas l'URL.
+
+#### 5. Métadonnées et état
+
+Tout passe par le SSE existant — titre, artiste, artwork, position, état de lecture.
+Pas de nouveau mécanisme nécessaire.
+
+#### 6. Seek
+
+Flux HTTP live → pas de Range requests.
+
+Pour les fichiers (non-live) :
+- `PipelineControl::Seek(position_sec)` → pipeline repart depuis la nouvelle position
+- Légère interruption du flux FLAC (rebuffering navigateur ~1s) — acceptable
+
+#### 7. Sources supportées
+
+Le pipeline réutilise `pmoaudio-ext` et `pmoflac`. La seule source actuellement
+déclarée dans `pmoaudio-ext` fonctionne à partir d'une `pmoplaylist` — c'est le
+modèle à suivre pour construire dans `source_loader.rs` une source ad-hoc capable
+d'ouvrir des URIs arbitraires (URL HTTP externe, fichier local/Samba) qui ne passent
+pas par le cache.
+
+### État partagé par instance
+
+```rust
+pub struct WebRendererServerState {
+    pub playback_state: PlaybackState,
+    pub current_uri: Option<String>,
+    pub volume: u16,
+    pub mute: bool,
+    pub stream_handle: SharedStreamHandle,   // Handle vers le flux FLAC
+    pub pipeline_tx: mpsc::Sender<PipelineControl>,  // Contrôle du pipeline
+}
+
+pub enum PipelineControl {
+    LoadUri(String),
+    LoadNextUri(String),
+    Play,
+    Pause,
+    Stop,
+    Seek(f64),
+    SetVolume(u16),
+}
+```
+
+## Fichiers à créer / modifier
+
+### Nouveaux fichiers
+
+| Fichier | Rôle |
+|---------|------|
+| `pmowebrenderer/src/stream.rs` | Handler HTTP du flux FLAC |
+| `pmowebrenderer/src/pipeline.rs` | Pipeline audio serveur par instance |
+| `pmowebrenderer/src/source_loader.rs` | Ouverture des sources (cache, HTTP, fichier local) |
+| `pmowebrenderer/src/register.rs` | Handler `POST /register` + `DELETE /{id}` |
+
+### Fichiers à modifier
+
+| Fichier | Modification |
+|---------|--------------|
+| `pmowebrenderer/src/state.rs` | Ajouter `stream_handle` et `pipeline_tx` |
+| `pmowebrenderer/src/handlers.rs` | `set_uri_handler` → `PipelineControl::LoadUri` |
+| `pmowebrenderer/src/websocket.rs` | **Supprimer** — remplacé par `register.rs` |
+| `pmowebrenderer/src/config.rs` | Enregistrer les nouvelles routes, supprimer WS |
+| `pmowebrenderer/src/messages.rs` | **Supprimer** — plus de WebSocket |
+| `pmowebrenderer/src/session.rs` | Adapter : session liée au flux FLAC, pas au WS |
+| `pmoapp/webapp/src/` | Remplacer WS par `POST /register` + `<audio src=stream_url>` |
+
+## Infrastructure existante réutilisable
+
+Tout le travail difficile est déjà fait :
+
+- **`StreamingFlacSink`** (`pmoaudio-ext/src/sinks/streaming_flac_sink.rs`) — broadcast multi-clients, gestion backpressure, ICY metadata
+- **`timed_broadcast`** (`pmoaudio-ext/src/sinks/timed_broadcast.rs`) — diffusion multi-clients avec pacing
+- **`pmoflac`** — décodage/encodage FLAC temps réel
+- Pattern HTTP streaming (`pmomediaserver/src/paradise_streaming.rs`) — exemple complet à suivre
+
+## Questions ouvertes
+
+1. **Volume côté serveur ou navigateur** ? Actuellement le navigateur gère le volume.
+   Côté serveur, on pourrait appliquer un gain DSP dans le pipeline.
+
+3. **Plusieurs onglets simultanés** : chaque onglet a son propre pipeline et flux ?
+   Ou partage d'un flux broadcast si même contenu ? (Complexe, probablement un pipeline par instance.)
+
+4. **Reconnexion** : si le navigateur se reconnecte (reload), le pipeline continue de
+   tourner ? Ou on le stoppe et recrée ? La `StreamHandle` permet plusieurs souscripteurs,
+   donc la reconnexion peut se faire sans interruption.
+
+5. **Latence** : le pipeline serveur introduit une latence (buffering + encodage).
+   À mesurer et potentiellement configurer via `max_lead_seconds`.

Blackboard/Todo/Frontend_Review.md

@@ -0,0 +1,327 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+## Contexte
+
+Ce document est le résultat d'une revue de code complète du frontend Vue.js/TypeScript du Control Point
+(`pmoapp/webapp/src/`). L'application est fonctionnelle mais présente plusieurs classes de problèmes
+qui peuvent causer des fuites mémoire, des incohérences de réactivité Vue 3, et des difficultés de
+maintenance à mesure que l'app grandit.
+
+**Périmètre** : uniquement `pmoapp/webapp/src/` (composants, services, composables, stores, utils, CSS).
+
+---
+
+## Problèmes identifiés
+
+### P0 — Fuites mémoire via listeners SSE jamais nettoyés
+
+**Fichiers** : `src/composables/useSSE.ts`, `src/composables/useRenderers.ts`,
+`src/composables/useMediaServers.ts`
+
+Les abonnements aux événements SSE sont créés lors du premier appel de chaque composable, mais
+jamais nettoyés si le composable est réutilisé ou le composant détruit. Dans `useSSE.ts`, la
+fonction `onRendererEvent()` retourne une fonction de cleanup, mais `useRendererEvents()` ignore
+ce retour — l'abonnement reste actif indefiniment.
+
+De plus, dans `imageCache.ts`, un `setInterval` de cleanup s'exécute toutes les 5 minutes sans
+jamais être annulé si l'app est détruite.
+
+### P1 — Réactivité Vue incohérente avec `shallowRef` + Maps
+
+**Fichier** : `src/composables/useRenderers.ts` (L23-37)
+
+`snapshots` et `loadingIds` sont déclarés en `shallowRef<Map<...>>()`. Vue ne détecte pas les
+mutations d'objets à l'intérieur d'un `shallowRef`. La solution actuelle — `triggerSnapshotReactivity()`
+qui crée une nouvelle Map à chaque appel — force une re-render complète de tous les composants
+qui dépendent de `snapshots`, même si seul un renderer a changé.
+
+### P2 — Race condition à l'initialisation (main.ts)
+
+**Fichier** : `src/main.ts`
+
+Le UIStore est initialisé après le montage de l'app et l'appel à `sse.connect()`. Des événements
+SSE peuvent arriver avant que `useUIStore()` soit appelé dans les composants, et les notifications
+correspondantes peuvent être perdues.
+
+### P3 — SSE singleton sans garantie formelle
+
+**Fichiers** : `src/composables/useRenderers.ts`, `src/composables/useMediaServers.ts`
+
+Chaque composable maintient son propre flag `sseInitialized` pour éviter les double-abonnements.
+Le mécanisme repose sur une convention implicite fragile : si deux composables s'abonnent au même
+type d'événement SSE dans des contextes différents, les callbacks s'accumulent sans être
+dédupliqués.
+
+Dans `useSSE.ts`, `setupConnectionListener()` vérifie `connectionCallbacks.size === 0` mais
+sans lock — deux appels simultanés peuvent installer deux listeners.
+
+### P4 — Pas de timeout ni retry sur les requêtes `fetch`
+
+**Fichier** : `src/services/pmocontrol/api.ts`
+
+Toutes les requêtes `fetch()` sont émises sans `AbortController`. Si le serveur ne répond pas,
+la promesse pend indéfiniment, bloquant potentiellement les composants qui attendent le résultat.
+Il n'y a ni timeout configurable ni retry automatique au niveau du service.
+
+### P5 — Validation absente des réponses API
+
+**Fichiers** : `src/services/audioCache.ts` (L76), `src/services/coverCache.ts`,
+`src/services/playlists.ts`, `src/services/pmocontrol/api.ts`
+
+Les réponses JSON sont acceptées sans vérification de structure. Une assertion de type comme
+`metadata as { origin_url?: unknown }` ne protège pas contre un changement d'API côté Rust. Si
+l'API retourne une structure inattendue, le crash survient au runtime, pas à la compilation.
+
+### P6 — Type assertions dangereuses dans PMOPlayer
+
+**Fichier** : `src/services/pmosource.ts` / PMOPlayer (L197-214)
+
+Les messages de commande sont typés `Record<string, unknown>`, puis les propriétés sont castées
+directement : `msg.url as string`, `msg.timestamp as number`. Si une propriété est absente ou
+d'un type différent, TypeScript ne le détecte pas.
+
+### P7 — `useTabs` : watch multiples sans debounce, flag de restauration non-réinitialisé
+
+**Fichier** : `src/composables/useTabs.ts` (L44, L350-361)
+
+Trois `watch()` séparées écrivent dans `localStorage`. Sans debounce commun, si 3 onglets
+changent d'état simultanément, `localStorage` est écrit 3 fois de suite.
+
+Le flag `isRestoringFromStorage` (L44) empêche la boucle de sauvegarde pendant la restauration,
+mais sans timeout : si `restoreFromLocalStorage()` lance une exception non-catchée, le flag reste
+`true` et toutes les sauvegardes futures sont silencieusement ignorées.
+
+### P8 — Routes de debug exposées en production, pas de lazy loading
+
+**Fichier** : `src/router/index.ts`
+
+Les routes debug (CoversCache, AudioCache, UPnP Explorer, etc.) sont accessibles en production
+sans contrôle d'accès. Par ailleurs, tous les composants sont importés statiquement, augmentant
+le bundle initial inutilement — les vues debug notamment ne sont jamais utilisées en prod.
+
+### P9 — `formatMsToShortTime` est un alias inutile
+
+**Fichier** : `src/utils/time.ts` (L58-59)
+
+```typescript
+// Actuellement
+export function formatMsToShortTime(ms: number | null): string {
+    return formatMsToTime(ms);
+}
+```
+
+Fonction identique à `formatMsToTime`. Tous les appelants peuvent utiliser directement
+`formatMsToTime`.
+
+### P10 — `truncate()` dans `string.ts` peut dépasser `maxLength`
+
+**Fichier** : `src/utils/string.ts` (L46-48)
+
+```typescript
+// Actuellement
+export function truncate(str: string, maxLength: number, suffix = '…'): string {
+    return str.length > maxLength ? str.slice(0, maxLength - suffix.length) + suffix : str;
+}
+```
+
+Si `suffix.length >= maxLength`, `str.slice(0, maxLength - suffix.length)` retourne une chaîne
+de longueur négative (comportement silencieux en JS, retourne `''`), et le résultat final est
+plus long que `maxLength`.
+
+### P11 — `DEFAULT_COVER_SVG` inline dans coverCache.ts
+
+**Fichier** : `src/services/coverCache.ts` (L206-226)
+
+Un SVG inline de ~20 lignes est inclus dans chaque bundle qui importe `coverCache`. Il devrait
+être un fichier `src/assets/default-cover.svg` importé nativement par Vite (ce qui permet le
+tree-shaking et le caching HTTP séparé).
+
+### P12 — `animations` CSS sans `prefers-reduced-motion`
+
+**Fichiers** : `src/assets/styles/glass-theme.css` (L384-401),
+`src/assets/styles/pmocontrol.css` (L82)
+
+Les animations `glassShimmer` (2s infini) et le `pulse` du badge de statut `Transitioning`
+s'exécutent sans tenir compte de `prefers-reduced-motion: reduce`. Sur certains systèmes ou
+pour des utilisateurs sensibles au mouvement, ces animations sont gênantes.
+
+### P13 — CSS dupliqué dans drawers.css
+
+**Fichier** : `src/assets/styles/drawers.css` (L105-149)
+
+`drawer-close-btn` et `drawer-back-btn` partagent 90% des styles. Un TODO présent en L167
+("remplacer par la classe globale .section-title") confirme cette dette. La variable
+`var(--opacity-disabled)` est utilisée mais non définie dans `variables.css`.
+
+### P14 — `browseContainer` : clés de cache fragiles et pas de pagination
+
+**Fichier** : `src/composables/useMediaServers.ts` (L145, L239)
+
+Les clés de cache sont construites comme `${serverId}/${containerId}`. Si un `containerId`
+contient un slash (séparateur d'URL), la clé est ambigüe. Par exemple, `server1/a/b` peut
+correspondre à serverId=`server1`, containerId=`a/b` ou serverId=`server1/a`, containerId=`b`.
+
+La pagination n'est pas implémentée côté composable : `browseContainer` charge toujours
+offset=0, limit=50. Pour les containers avec 500+ items, les items au-delà de 50 ne sont
+jamais accessibles.
+
+### P15 — Notifications sans limite de taille dans `ui.ts`
+
+**Fichier** : `src/stores/ui.ts` (L50, L55-57)
+
+Un bug ou une boucle d'erreur peut générer des centaines de notifications. Le tableau
+`notifications` n'est pas limité. Chaque notification crée un `setTimeout` individuel, et
+si le store est détruit avant l'expiration, ces callbacks persistent (ghosts).
+
+---
+
+## Plan d'exécution
+
+Les corrections sont groupées par effort et impact. Les P0–P3 concernent la fiabilité
+(fuites mémoire, réactivité), les P4–P8 la robustesse et maintenabilité, les P9–P15 la
+qualité et la dette technique.
+
+### Étape 1 — Corriger les fuites mémoire SSE (P0)
+
+Dans `useSSE.ts`, stocker et appeler les fonctions de cleanup retournées par `onRendererEvent` /
+`onMediaServerEvent` :
+
+```typescript
+// useSSE.ts – useRendererEvents()
+onMounted(() => {
+    const cleanup = onRendererEvent(rendererId(), handler);
+    onUnmounted(cleanup);  // ← actuellement ignoré
+});
+```
+
+Dans `imageCache.ts`, exporter une fonction `destroyImageCache()` qui appelle `clearInterval`
+sur le timer de cleanup, et l'appeler dans le `onUnmounted` de l'app root.
+
+### Étape 2 — Stabiliser la réactivité des snapshots (P1)
+
+Remplacer `shallowRef<Map<...>>` + `triggerSnapshotReactivity` par `reactive(new Map<...>)`.
+Vue 3 rend les Maps réactives nativement. Les composants qui lisent `snapshots.get(id)`
+seront notifiés uniquement si ce `id` change.
+
+```typescript
+// Avant
+const snapshots = shallowRef<Map<string, FullRendererSnapshot>>(new Map());
+function triggerSnapshotReactivity() {
+    snapshots.value = new Map(snapshots.value);
+}
+
+// Après
+const snapshots = reactive(new Map<string, FullRendererSnapshot>());
+// Les modifications directes (snapshots.set/delete) déclenchent la réactivité
+```
+
+### Étape 3 — Timeout fetch + AbortController (P4)
+
+Ajouter un helper dans `api.ts` :
+
+```typescript
+function fetchWithTimeout(url: string, options?: RequestInit, timeoutMs = 10_000): Promise<Response> {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeoutMs);
+    return fetch(url, { ...options, signal: controller.signal })
+        .finally(() => clearTimeout(id));
+}
+```
+
+Utiliser `fetchWithTimeout` pour toutes les requêtes dans le service API.
+
+### Étape 4 — Corriger `useTabs` watchs et flag de restauration (P7)
+
+Fusionner les trois `watch()` en un seul `watchEffect` avec un debounce unique (100ms).
+Encadrer `isRestoringFromStorage` dans un bloc `try/finally` :
+
+```typescript
+async function restoreFromLocalStorage() {
+    isRestoringFromStorage = true;
+    try {
+        // ... logique de restauration
+    } catch (e) {
+        console.error('Tab restore failed:', e);
+    } finally {
+        isRestoringFromStorage = false;
+    }
+}
+```
+
+### Étape 5 — Limit de notifications et nettoyage timers (P15)
+
+```typescript
+const MAX_NOTIFICATIONS = 5;
+
+function addNotification(notif: Omit<Notification, 'id'>): void {
+    if (notifications.value.length >= MAX_NOTIFICATIONS) {
+        notifications.value.shift(); // supprimer la plus ancienne
+    }
+    const id = nextId++;
+    const timer = setTimeout(() => removeNotification(id), notif.duration ?? 5000);
+    notificationTimers.set(id, timer);
+    notifications.value.push({ ...notif, id });
+}
+
+function $dispose() {
+    notificationTimers.forEach(clearTimeout);
+    notificationTimers.clear();
+}
+```
+
+### Étape 6 — Lazy loading des routes et protection debug (P8)
+
+```typescript
+// router/index.ts
+const DebugView = () => import('../views/DebugView.vue');
+const isDev = import.meta.env.DEV;
+
+const routes = [
+    // ... routes normales
+    ...(isDev ? [{ path: '/debug', component: DebugView }] : []),
+    { path: '/:pathMatch(.*)*', redirect: '/' }, // wildcard 404
+];
+```
+
+### Étape 7 — Corrections mineures (P9, P10, P11, P12, P13)
+
+- **P9** : Supprimer `formatMsToShortTime`, remplacer tous les appels par `formatMsToTime`
+- **P10** : Ajouter un guard dans `truncate` : `if (suffix.length >= maxLength) return str.slice(0, maxLength)`
+- **P11** : Déplacer le SVG dans `src/assets/default-cover.svg` et l'importer avec `import defaultCover from '../assets/default-cover.svg?raw'`
+- **P12** : Entourer les animations CSS avec `@media (prefers-reduced-motion: no-preference) { ... }`
+- **P13** : Factoriser `drawer-close-btn` / `drawer-back-btn` avec une classe `.drawer-icon-btn`. Définir `--opacity-disabled: 0.4` dans `variables.css`
+
+### Étape 8 — Clés de cache et pagination (P14)
+
+Encoder les IDs dans les clés de cache :
+
+```typescript
+const cacheKey = `${encodeURIComponent(serverId)}:${encodeURIComponent(containerId)}`;
+```
+
+Utiliser `:` comme séparateur (absent de l'encoding) pour éviter toute ambigüité.
+
+Pour la pagination, ajouter une propriété `hasMore: boolean` et `loadMore()` au résultat de
+`browseContainer`, incrementant offset à chaque appel.
+
+### Ordre d'exécution
+
+1. Étape 1 — fuites SSE (P0) — fiabilité critique
+2. Étape 2 — réactivité Map (P1) — fiabilité
+3. Étape 3 — timeout fetch (P4) — robustesse réseau
+4. Étape 4 — useTabs (P7) — fiabilité des onglets
+5. Étape 5 — notifications (P15) — stabilité UI
+6. Étape 6 — router (P8) — sécurité + performance bundle
+7. Étape 7 — corrections mineures (P9–P13)
+8. Étape 8 — cache keys + pagination (P14)
+
+## Règle après ces corrections
+
+**Interdit** : créer un abonnement SSE (`onRendererEvent`, `onMediaServerEvent`) sans stocker
+et appeler la fonction de cleanup retournée dans `onUnmounted`.
+
+**Interdit** : utiliser `shallowRef<Map<...>>` avec mutation directe — utiliser `reactive(new Map())`
+pour les Maps qui doivent déclencher la réactivité Vue sur leurs entrées.
+
+**Obligatoire** : toute requête `fetch()` dans un service doit utiliser `fetchWithTimeout`
+avec un AbortController.

Blackboard/Todo/centraliser_base_url_axum_middleware.md

@@ -0,0 +1,459 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+## Problème
+
+Quand le site est accédé via une adresse externe (reverse proxy, ex: `orbis.petite-maison-orange.fr`),
+les URLs d'images et de ressources générées par le backend contiennent l'IP locale hardcodée
+(ex: `http://192.168.0.32:80/covers/image/...`). Ces URLs sont inaccessibles depuis l'extérieur.
+
+## Cause racine
+
+Il existe deux contextes distincts de construction d'URL dans pmomusic :
+
+**A. Contexte UPnP / réseau local** : les URLs doivent être absolues avec l'IP locale, car les
+renderers UPnP accèdent directement aux ressources sur le réseau local.
+→ Elles utilisent correctement `PMO_SERVER_URL` / `covers_absolute_url_for()`.
+
+**B. Contexte HTTP / frontend webapp** : les URLs retournées au navigateur doivent refléter l'hôte
+vu par le client (local ou via proxy). Elles utilisent actuellement aussi `PMO_SERVER_URL` —
+c'est le bug.
+
+`pmoserver` dispose déjà de `request_base_url(headers)` (`pmoserver/src/server.rs:633`) qui lit
+`X-Forwarded-Proto` / `X-Forwarded-Host` / `Host` et retourne la base URL correcte par requête.
+Mais **aucun handler HTTP ne l'utilise** pour construire les URLs retournées au frontend.
+
+## Solution : Middleware Axum BaseUrl
+
+Ajouter un middleware Axum au niveau de la racine du routeur qui enrichit chaque requête d'une
+`Extension<BaseUrl>` calculée depuis les headers. Tous les handlers HTTP qui retournent des URLs
+au frontend extraient cette extension — **un seul point de calcul, zéro gestion ad hoc**.
+
+### 1. Nouveau type `BaseUrl` dans `pmoserver/src/lib.rs`
+
+```rust
+/// URL de base effective pour la requête courante.
+/// Calculée depuis X-Forwarded-Proto/Host ou Host header.
+/// Injectée par `base_url_layer` dans toutes les requêtes Axum.
+#[derive(Debug, Clone)]
+pub struct BaseUrl(pub String);
+```
+
+### 2. Middleware `base_url_layer` dans `pmoserver/src/lib.rs`
+
+```rust
+/// Middleware Axum : injecte BaseUrl dans chaque requête.
+/// À appliquer sur le routeur racine via `.layer(base_url_layer())`.
+pub fn base_url_layer() -> axum::middleware::FromFnLayer<...> {
+    axum::middleware::from_fn(|request: Request, next: Next| async move {
+        // Fallback sur PMO_SERVER_URL (valeur de démarrage avec la vraie IP/port),
+        // pas sur localhost:8080 hardcodé.
+        let base = get_request_base_url(request.headers())
+            .or_else(|| std::env::var("PMO_SERVER_URL").ok())
+            .unwrap_or_else(|| {
+                tracing::warn!("BaseUrl: aucun header Host/X-Forwarded-Host ni PMO_SERVER_URL — fallback localhost:8080");
+                "http://localhost:8080".to_string()
+            });
+        let mut request = request;
+        tracing::debug!("BaseUrl calculée : {}", base);
+        request.extensions_mut().insert(BaseUrl(base));
+        next.run(request).await
+    })
+}
+```
+
+### 3. Application du layer dans `pmoserver/src/server.rs`
+
+Dans Axum, le dernier `.layer()` appliqué est le plus extérieur (exécuté en premier sur la
+requête entrante). Pour que `base_url_layer` voie les headers **après** tout layer de nettoyage,
+il doit être **intérieur** — donc appliqué **avant** dans le code :
+
+```rust
+router
+    .layer(header_clean_layer())  // extérieur → exécuté en premier, nettoie les headers
+    .layer(base_url_layer())      // intérieur → voit les headers nettoyés
+```
+
+Les endpoints UPnP (SSDP, description XML, control, event) ne doivent pas appeler
+`covers_absolute_url_for_upnp()` via `BaseUrl` — l'injection du middleware ne les affecte pas
+puisqu'ils n'extraient pas `Extension<BaseUrl>`.
+
+Si des routes non-HTTP sont ajoutées ultérieurement (métriques internes, health checks sans
+contexte client), les isoler dans un sous-routeur dédié sans `base_url_layer()`.
+
+### 4. Utilisation dans les handlers
+
+Tous les handlers qui retournent des URLs au frontend ajoutent :
+
+```rust
+Extension(base_url): Extension<BaseUrl>,
+```
+
+Et utilisent `base_url.url_for(&pmocovers::covers_route_for(pk, None))` à la place de
+`covers_absolute_url_for()` (voir section 5 pour le pattern complet).
+
+Handlers REST concernés (liste non exhaustive) :
+- `pmocontrol/src/pmoserver_ext.rs` : `get_renderer_full_snapshot` (album_art_uri dans snapshot)
+- `pmocontrol/src/pmoserver_ext.rs` : handler browse (ContainerEntry.album_art_uri)
+- `pmoradiofrance/src/api_rest.rs` : endpoints playlist/metadata
+- `pmoplaylist/src/handle/read.rs` : album art dans les réponses playlist
+
+**Handlers SSE** (`pmocontrol/src/sse.rs`) : cas particulier. Le stream SSE est long-lived —
+après le `stream!` block, on n'est plus dans le contexte du handler Axum. `BaseUrl` doit être
+clonée dans une variable locale **avant** le `stream!`, puis `move`-ée dans la closure :
+
+```rust
+pub async fn renderer_events_sse(
+    State(control_point): State<Arc<ControlPoint>>,
+    Extension(base_url): Extension<BaseUrl>,   // ← extraite à la connexion
+) -> impl IntoResponse {
+    let base_url = base_url.clone(); // clone avant le stream! pour le move
+    // ...
+    let stream = stream! {
+        while let Some(event) = rx_tokio.recv().await {
+            // base_url est disponible ici par move
+            let payload = renderer_event_to_payload(event, &base_url);
+            yield Ok(Event::default()...);
+        }
+    };
+}
+
+### 5. Méthode `url_for` sur `BaseUrl` + fonctions `route_for` dans chaque crate
+
+La combinaison `base_url + route` est identique pour tous les types de ressources. Elle est
+factorisée en une méthode sur `BaseUrl` dans `pmoserver/src/lib.rs` :
+
+```rust
+impl BaseUrl {
+    /// Construit une URL absolue en combinant la base URL de la requête avec une route relative.
+    /// Usage : base_url.url_for(&pmocovers::covers_route_for(pk, None))
+    pub fn url_for(&self, route: &str) -> String {
+        debug_assert!(route.starts_with('/'), "route must start with '/'");
+        format!("{}{}", self.0.trim_end_matches('/'), route)
+    }
+}
+```
+
+Chaque crate spécialisée expose uniquement sa **route** (chemin relatif), pas l'URL complète :
+
+**`pmocovers/src/lib.rs`** — déplacer depuis `pmocache` :
+```rust
+/// Route relative d'une cover : `/covers/image/{pk}[/{param}]`
+pub fn covers_route_for(pk: &str, param: Option<&str>) -> String { ... }
+```
+
+**`pmoaudiocache/src/lib.rs`** :
+```rust
+/// Route relative d'un fichier audio : `/audio/flac/{pk}`
+pub fn audio_route_for(pk: &str) -> String {
+    format!("/audio/flac/{}", pk)
+}
+```
+
+Usage dans les handlers :
+```rust
+base_url.url_for(&pmocovers::covers_route_for(pk, None))
+base_url.url_for(&pmoaudiocache::audio_route_for(pk))
+```
+
+### 6. Renommage de `covers_absolute_url_for` → `covers_absolute_url_for_upnp`
+
+Pour rendre le contexte d'usage explicite et décourager l'appel depuis les handlers HTTP,
+renommer dans `pmocache/src/lib.rs` :
+
+```rust
+// Ancien nom — marqué deprecated pour faciliter la migration (warnings à la compilation)
+#[deprecated(note = "Utiliser covers_absolute_url_for_upnp() dans les contextes UPnP uniquement")]
+pub fn covers_absolute_url_for(pk: &str, param: Option<&str>) -> String { ... }
+
+// Nouveau nom — usage UPnP uniquement
+pub fn covers_absolute_url_for_upnp(pk: &str, param: Option<&str>) -> String { ... }
+```
+
+Mettre à jour tous les appels existants (contextes UPnP/DIDL uniquement) via un grep :
+`grep -rn "covers_absolute_url_for" src/ --include="*.rs"`
+
+À terme, `covers_route_for` et `covers_absolute_url_for_upnp` devraient migrer de `pmocache`
+vers `pmocovers`, mais ce n'est pas le périmètre de ce ticket.
+
+## URLs dans les documents DIDL et SSE
+
+Les documents DIDL bruts (`<res>`, `<upnp:albumArtURI>`) ne transitent jamais vers le frontend —
+pmocontrol les parse côté serveur et n'envoie que des champs extraits (JSON) via REST et SSE.
+Il n'y a donc pas de "rebasage XML" : les champs extraits (`album_art_uri`, etc.) passent tous
+par des handlers qui ont accès à `BaseUrl`.
+
+**SSE est per-client** : chaque connexion SSE crée son propre receiver (`subscribe_events()`).
+La `BaseUrl` est figée à l'établissement de la connexion et ne sera pas mise à jour si le client
+change de réseau en cours de stream — comportement attendu et documenté.
+Il n'y a ni canal partagé, ni duplication LAN/WAN. Le handler SSE capture `Extension<BaseUrl>`
+à l'établissement de la connexion et applique `base_url.url_for()` à toutes les URLs des événements
+émis vers ce client.
+
+Les DIDL servis directement aux renderers UPnP (hors HTTP webapp) gardent l'IP locale — c'est
+correct, les renderers sont sur le réseau local.
+
+## Audit préalable à l'implémentation
+
+Avant de modifier les handlers, faire un audit exhaustif de tous les endroits qui construisent
+des URLs absolues dans des réponses JSON au frontend :
+
+```bash
+# Appels directs aux fonctions URL connues
+grep -rn "covers_absolute_url_for\|audio/flac\|cache/audio" src/ --include="*.rs"
+
+# Constructions format! utilisant PMO_SERVER_URL ou des littéraux http://
+grep -rn "PMO_SERVER_URL\|format!.*base_url\|format!.*server_url" src/ --include="*.rs"
+grep -rn 'format!.*"http' src/ --include="*.rs"
+```
+
+Note : les PKs de covers et audio sont des hashes hex (`[0-9a-f]+`) — ils ne peuvent pas
+contenir de caractères spéciaux nécessitant un encodage URL. La concaténation `format!` est
+donc sûre ; pas besoin de `url::Url::join`.
+
+## Tests à écrire
+
+- **Middleware** : `BaseUrl` correctement extraite depuis `X-Forwarded-Host`, `Host`, et en
+  leur absence (fallback sur `PMO_SERVER_URL`)
+- **`url_for`** : assertion que toutes les routes commencent par `/` ; pas de double slash ;
+  trailing slash sur la base géré par `trim_end_matches`
+- **Handlers REST** : `album_art_uri` rebased dans `FullRendererSnapshot` et `BrowseResponse`
+- **SSE** : URLs rebased dans les événements `TrackChanged`
+- **UPnP** : vérifier que les URLs servies aux renderers UPnP restent en IP locale (non affectées
+  par `BaseUrl`)
+- **Intégration** : appeler **chaque endpoint frontend** avec un client HTTP de test pour
+  vérifier (a) qu'aucune panique ne se produit (middleware bien appliqué) et (b) que les URLs
+  produites utilisent l'hôte du header `X-Forwarded-Host` simulé et non l'IP locale.
+  La panique sur `Extension<BaseUrl>` manquante est un comportement voulu — elle doit être
+  détectée par ces tests et non silencieusement masquée par un `Option`.
+
+## Sécurité : headers X-Forwarded-*
+
+Les headers `X-Forwarded-Proto` / `X-Forwarded-Host` peuvent être forgés par n'importe quel client
+si le reverse proxy ne les filtre pas. Dans le contexte de déploiement de pmomusic (usage domestique,
+proxy Nginx/Caddy unique), le risque est faible et hors périmètre de ce ticket.
+
+À surveiller si le déploiement évolue : restreindre la lecture de ces headers aux requêtes venant
+de l'IP du proxy (liste blanche de proxies de confiance côté Axum ou côté proxy).
+
+## Périmètre : ce qui ne change PAS
+
+- `covers_absolute_url_for()` dans `pmocache` : conservée pour les contextes UPnP
+- `PMO_SERVER_URL` env var : conservée pour UPnP et les processus non-HTTP
+- URLs dans les DIDL servis aux renderers UPnP : inchangées (doivent rester en IP locale)
+- `server_base_url` passé aux sources (RadioFrance, RadioParadise, Qobuz) : inchangé
+  (ces sources construisent des URLs pour les renderers réseau)
+
+## Plan d'exécution
+
+### Corrections d'audit préalables
+
+Divergences entre le document et le code réel :
+
+- **Route audio** : `/audio/tracks/{pk}` (PAS `/audio/flac/{pk}`)
+- **`covers_route_for`** existe déjà dans `pmocache/src/lib.rs:149` — à copier vers `pmocovers`
+- **`album_art_uri`** dans les handlers est propagé depuis des caches amont ; le point de
+  construction réel est `pmoradiofrance/src/metadata_cache.rs:263` (tâche de fond, pas un handler)
+- **`pmoqobuz/src/source.rs:1943`** construit des URLs audio avec `self.base_url` → contexte
+  UPnP/renderer, hors périmètre de ce ticket
+
+### Étape 0 — Audit exhaustif (avant tout changement)
+
+```bash
+grep -rn "covers_absolute_url_for\|audio/tracks\|cache/audio" --include="*.rs"
+grep -rn "PMO_SERVER_URL\|format!.*base_url\|format!.*server_url" --include="*.rs"
+grep -rn 'format!.*"http' --include="*.rs"
+```
+
+Identifier tous les call sites dans les contextes HTTP (handlers, caches de métadonnées servant
+le frontend). Distinguer des contextes UPnP/renderer (hors périmètre).
+
+### Étape 1 — `pmoserver/src/lib.rs` : ajouter `BaseUrl` + `base_url_layer`
+
+`get_request_base_url(headers)` existe déjà à la ligne 199. Ajouter :
+
+```rust
+use axum::{extract::Request, middleware::Next, response::Response};
+
+#[derive(Debug, Clone)]
+pub struct BaseUrl(pub String);
+
+impl BaseUrl {
+    pub fn url_for(&self, route: &str) -> String {
+        debug_assert!(route.starts_with('/'), "route must start with '/'");
+        format!("{}{}", self.0.trim_end_matches('/'), route)
+    }
+}
+
+pub async fn base_url_middleware(mut request: Request, next: Next) -> Response {
+    let base = get_request_base_url(request.headers())
+        .unwrap_or_else(|| {
+            std::env::var("PMO_SERVER_URL").unwrap_or_else(|_| {
+                tracing::warn!(
+                    "BaseUrl: aucun header Host/X-Forwarded-Host ni PMO_SERVER_URL \
+                     — fallback localhost:8080"
+                );
+                "http://localhost:8080".to_string()
+            })
+        });
+    tracing::debug!("BaseUrl calculée : {}", base);
+    request.extensions_mut().insert(BaseUrl(base));
+    next.run(request).await
+}
+
+pub fn base_url_layer() -> axum::middleware::FromFnLayer<...> {
+    axum::middleware::from_fn(base_url_middleware)
+}
+```
+
+### Étape 2 — `pmoserver/src/server.rs` : appliquer le layer
+
+Trouver la construction du routeur principal. Ajouter `base_url_layer()` avant les layers
+existants (= intérieur dans la pile Tower) :
+
+```rust
+router
+    .layer(some_existing_layer())   // extérieur → exécuté en premier
+    .layer(base_url_layer())        // intérieur → voit les headers après nettoyage
+```
+
+### Étape 3 — `pmocovers/src/lib.rs` : ajouter `covers_route_for`
+
+Copier depuis `pmocache/src/lib.rs:149` :
+
+```rust
+/// Route relative d'une cover : `/covers/image/{pk}[/{param}]`
+pub fn covers_route_for(pk: &str, param: Option<&str>) -> String {
+    if let Some(p) = param {
+        format!("/covers/image/{}/{}", pk, p)
+    } else {
+        format!("/covers/image/{}", pk)
+    }
+}
+```
+
+### Étape 4 — `pmoaudiocache/src/lib.rs` : ajouter `audio_route_for`
+
+```rust
+/// Route relative d'un fichier audio : `/audio/tracks/{pk}`
+pub fn audio_route_for(pk: &str) -> String {
+    format!("/audio/tracks/{}", pk)
+}
+```
+
+### Étape 5 — `pmocache/src/lib.rs` : renommer `covers_absolute_url_for`
+
+```rust
+#[deprecated(note = "Utiliser covers_absolute_url_for_upnp() dans les contextes UPnP uniquement")]
+pub fn covers_absolute_url_for(pk: &str, param: Option<&str>) -> String {
+    covers_absolute_url_for_upnp(pk, param)
+}
+
+pub fn covers_absolute_url_for_upnp(pk: &str, param: Option<&str>) -> String {
+    let base = std::env::var("PMO_SERVER_URL")
+        .unwrap_or_else(|_| "http://localhost:8080".to_string());
+    format!("{}{}", base.trim_end_matches('/'), covers_route_for(pk, param))
+}
+```
+
+Mettre à jour l'appel UPnP connu : `pmoupnp/src/cache_registry.rs:57`
+→ `covers_absolute_url_for(` → `covers_absolute_url_for_upnp(`
+
+### Étape 6 — `pmoradiofrance/src/metadata_cache.rs:263` : stocker la route, pas l'URL
+
+**Contexte** : tâche de fond — ne peut pas extraire `Extension<BaseUrl>`.
+**Principe** : stocker la route relative dans le cache ; le handler rebase au moment de la réponse.
+
+```rust
+// Avant :
+let public_url = pmocache::covers_absolute_url_for(&pk, None);
+
+// Après :
+let public_url = pmocovers::covers_route_for(&pk, None); // route relative
+```
+
+Le handler REST dans `pmoradiofrance/src/api_rest.rs` qui retourne ces métadonnées doit :
+1. Ajouter `Extension(base_url): Extension<BaseUrl>` à sa signature
+2. Construire l'URL : `base_url.url_for(&metadata.album_art_uri)`
+
+Lire `api_rest.rs` pour identifier le handler exact qui inclut `album_art_uri` dans la réponse.
+
+### Étape 7 — Handlers REST `pmocontrol/src/pmoserver_ext.rs`
+
+`get_renderer_full_snapshot` (l.170) et `browse_container` (l.2080) propagent `album_art_uri`
+depuis les résultats DIDL des media servers UPnP — ces URLs pointent vers l'IP du media server,
+pas de pmomusic.
+
+**Action** : après l'audit, vérifier si ces URLs passent par `covers_absolute_url_for`.
+Si oui → même traitement qu'étape 6. Sinon → pas de changement.
+
+### Étape 8 — Handlers SSE `pmocontrol/src/sse.rs`
+
+Pour `renderer_events_sse`, `media_server_events_sse`, `all_events_sse` :
+
+```rust
+pub async fn renderer_events_sse(
+    State(control_point): State<Arc<ControlPoint>>,
+    Extension(base_url): Extension<BaseUrl>,  // ← ajouter
+) -> impl IntoResponse {
+    let base_url = base_url.clone(); // avant le stream!
+    let stream = stream! {
+        while let Some(event) = rx.recv().await {
+            // base_url.url_for(...) pour les URLs dans les événements
+        }
+    };
+}
+```
+
+Vérifier si les événements SSE contiennent des `album_art_uri` construits avec
+`covers_absolute_url_for` ou propagés depuis le cache.
+Si propagation → même traitement qu'étape 6.
+
+### Étape 9 — Vérification finale
+
+```bash
+# Ne doit retourner aucun appel dans les handlers HTTP
+grep -rn "covers_absolute_url_for[^_]" --include="*.rs"
+
+# Ne doit retourner aucun résultat dans les handlers HTTP
+grep -rn "PMO_SERVER_URL" --include="*.rs" | grep -v "pmocache\|pmoserver\|test"
+
+# Warnings deprecated
+cargo build 2>&1 | grep "deprecated"
+```
+
+### Étape 10 — Tests
+
+```rust
+#[test]
+fn url_for_combines_base_and_route() {
+    let b = BaseUrl("https://example.com".to_string());
+    assert_eq!(b.url_for("/covers/image/abc"), "https://example.com/covers/image/abc");
+}
+
+#[test]
+fn url_for_trims_trailing_slash() {
+    let b = BaseUrl("https://example.com/".to_string());
+    assert_eq!(b.url_for("/covers/image/abc"), "https://example.com/covers/image/abc");
+}
+// + tests middleware X-Forwarded-Host, fallback PMO_SERVER_URL, fallback localhost
+// + test intégration : chaque endpoint frontend avec X-Forwarded-Host simulé
+```
+
+### Ordre d'exécution
+
+1. Étape 0 — audit (confirmer la liste des call sites)
+2. Étapes 3, 4 — ajouter `covers_route_for` / `audio_route_for` (sans breaking change)
+3. Étape 5 — renommer + `#[deprecated]` (les warnings guident la suite)
+4. Étape 1 — `BaseUrl` + `base_url_layer` dans `pmoserver`
+5. Étape 2 — appliquer le layer dans `server.rs`
+6. Étapes 6, 7, 8 — migrer les handlers (guidés par les warnings de compilation)
+7. Étapes 9, 10 — vérification + tests
+
+## Règle après cette modification
+
+**Interdit** : appeler `covers_absolute_url_for_upnp()`, lire `PMO_SERVER_URL`, ou utiliser
+`format!("{}/audio/flac/{}", base_url, pk)` dans un handler HTTP qui retourne du JSON au frontend.
+
+**Obligatoire** : extraire `Extension<BaseUrl>` et utiliser :
+- `base_url.url_for(&pmocovers::covers_route_for(pk, None))` pour les images
+- `base_url.url_for(&pmoaudiocache::audio_route_for(pk))` pour les fichiers audio

Blackboard/Todo/enorme_playlist.md

@@ -0,0 +1,426 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+## Contexte et symptôme
+
+Le control point PMOMusic est lent lorsqu'un renderer **OpenHome** manipule des playlists
+d'environ 1 000 titres. Les renderers Chromecast et UPnP pur ne sont pas affectés : ils
+utilisent une `InternalQueue` entièrement locale, sans appels SOAP. Le problème est
+spécifique à `OpenHomeQueue` (`pmocontrol/src/queue/openhome.rs`).
+
+Le code a été généré par IA : il peut contenir des redondances, mais **chaque comportement
+est intentionnel**. L'objectif est d'optimiser sans rien supprimer.
+
+## Causes racines identifiées
+
+### P0 — Double appel à `queue_snapshot()` dans `sync_queue()`
+
+**Fichiers** : `pmocontrol/src/queue/openhome.rs`
+
+`sync_queue()` (ligne 1151) appelle `queue_snapshot()` pour obtenir l'état courant.
+Puis elle délègue à l'une de ces deux sous-fonctions qui appellent **à nouveau**
+`queue_snapshot()` :
+
+- `replace_queue_with_pivot()` (ligne 555) : 2e appel `queue_snapshot()` + 1 appel
+  `track_ids()` séparé (alors que `queue_snapshot()` appelle déjà `track_ids()` en interne)
+- `replace_queue_standard_lcs()` (ligne 647) : 2e appel `queue_snapshot()`
+
+Seule `replace_queue_preserve_current()` n'a pas ce défaut (elle appelle uniquement
+`track_ids()`).
+
+**Impact pour 1 000 titres :**
+
+Chaque `queue_snapshot()` exécute :
+- 1 appel SOAP `IdArray` (liste des IDs)
+- 16 appels SOAP `ReadList` (lots de 64 items)
+
+Soit **34 appels SOAP** pour une seule opération `sync_queue()` au lieu de 17.
+
+Le cache `ReadList` (TTL 500 ms) atténue partiellement mais ne supprime pas le problème
+car la durée d'un `sync_queue` sur 1 000 titres peut dépasser 500 ms.
+
+### P1 — Algorithme LCS de complexité quadratique O(m × n)
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs:851`
+
+La fonction `lcs_flags()` alloue une table DP de taille `(m+1) × (n+1)` :
+
+```rust
+let mut dp = vec![vec![0u32; n + 1]; m + 1];
+```
+
+Pour 1 000 titres en entrée : 1 000 × 1 000 = **1 000 000 entrées** (≈ 4 MB), et
+1 000 000 comparaisons. Elle est appelée **jusqu'à 3 fois** dans un seul `sync_queue` :
+- 2 fois dans `replace_queue_with_pivot()` (avant et après le pivot, lignes 579 et 582)
+- 1 fois dans `replace_queue_standard_lcs()` (ligne 661)
+
+Dans le cas courant (ajout de titres en fin de liste, ou liste déjà synchronisée),
+la quasi-totalité de la table DP est inutile : les préfixe et suffixe communs
+représentent souvent 90 % ou plus de la liste.
+
+### P2 — Taille de lot `ReadList` = 64
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs:986`
+
+```rust
+const MAX_BATCH: usize = 64;
+```
+
+Pour 1 000 titres : 1 000 ÷ 64 = **16 appels SOAP `ReadList`** par `queue_snapshot()`.
+La latence réseau typique par appel SOAP (50–200 ms) implique 0,8 à 3,2 secondes
+uniquement pour la lecture des métadonnées.
+
+La norme OpenHome Playlist ne fixe pas de limite de payload. La valeur 64 est
+conservatrice. Augmenter à 256 réduit à **4 appels** (−75 %).
+
+Le mécanisme de fallback one-by-one (lignes 1007–1019) assure la rétrocompatibilité
+avec les devices qui refuseraient un payload plus large.
+
+### P3 — Polling à 500 ms indépendant de l'activité
+
+**Fichier** : `pmocontrol/src/music_renderer/watcher.rs`
+
+Chaque renderer OpenHome tourne un thread watcher toutes les 500 ms, même en veille.
+Avec plusieurs renderers actifs, les appels de polling et les opérations `sync_queue`
+se chevauchent sur le même device réseau, créant de la contention.
+
+### P4 — Redondances de code (nettoyage conservatif)
+
+**a. Invalidation des caches dupliquée** (`openhome.rs`)
+
+La séquence d'invalidation apparaît en 3 endroits distincts (lignes 1134–1136,
+454–456, 634–635) :
+
+```rust
+self.track_ids_cache.lock().unwrap().invalidate();
+self.read_list_cache.lock().unwrap().invalidate();
+// parfois aussi :
+self.current_track_id_cache.lock().unwrap().invalidate();
+```
+
+**b. Protection durée stream dupliquée** (`openhome.rs` et `interne.rs`)
+
+La logique de protection de durée pour les flux continus (radio) est implémentée :
+- Dans `cache_metadata()` de `OpenHomeQueue` (`openhome.rs:250–351`)
+- Dans `protect_stream_durations()` de `InternalQueue` (`interne.rs:92–143`)
+- Dans `merge_metadata_protecting_streams()` de `InternalQueue` (`interne.rs:148–215`)
+
+**c. `parse_duration()` défini 3 fois**
+
+La conversion `HH:MM:SS` → secondes apparaît dans `openhome.rs`, `interne.rs`,
+et dans `time_utils::parse_hhmmss_u32()` (déjà publique).
+
+## Ce qui fonctionne déjà correctement
+
+**Pagination du Browse** : La boucle de pagination est correctement implémentée dans
+`control_point.rs:1610–1653` avec `browse_children()` + offset incrémental.
+
+**Fallback ReadList one-by-one** : Si un batch échoue, le retry unitaire (lignes 1007–1019)
+assure la robustesse sur les devices stricts.
+
+**Protection multi-control-point** : `delete_id_if_exists()` gère proprement le cas où
+un autre control point a déjà supprimé un titre.
+
+**Stratégie double-LCS avec pivot** : La logique de `replace_queue_with_pivot()` est
+correcte et importante pour ne pas interrompre la lecture en cours.
+
+**Cache métadonnées stream** : La protection de durée décroissante pour les flux radio
+est un comportement essentiel à préserver scrupuleusement.
+
+## Plan d'exécution
+
+### Crate concernée : `pmocontrol`
+
+---
+
+### Étape 1 — Augmenter le batch `ReadList` à 256
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs:986`
+
+```rust
+// Avant
+const MAX_BATCH: usize = 64;
+
+// Après
+const MAX_BATCH: usize = 256;
+```
+
+Le fallback one-by-one (lignes 1007–1019) reste intact. Si un renderer refuse
+un payload de 256 IDs, il retombe automatiquement sur le mode unitaire.
+
+---
+
+### Étape 2 — Éliminer le double appel à `queue_snapshot()`
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs`
+
+Le snapshot calculé dans `sync_queue()` contient déjà les items **et** leurs IDs
+backend (`backend_id: usize`). Il n'est pas nécessaire de le recalculer dans les
+sous-fonctions.
+
+#### 2a. Passer le snapshot à `replace_queue_with_pivot()`
+
+Signature actuelle (ligne 548) :
+```rust
+fn replace_queue_with_pivot(
+    &mut self,
+    new_items: Vec<PlaybackItem>,
+    pivot_idx_new: usize,
+    pivot_id: usize,
+) -> Result<(), ControlPointError>
+```
+
+Nouvelle signature :
+```rust
+fn replace_queue_with_pivot(
+    &mut self,
+    new_items: Vec<PlaybackItem>,
+    pivot_idx_new: usize,
+    pivot_id: usize,
+    snapshot: &QueueSnapshot,           // ← ajouté
+    current_track_ids: &[u32],          // ← ajouté (évite aussi le 2e appel track_ids())
+) -> Result<(), ControlPointError>
+```
+
+À l'intérieur de `replace_queue_with_pivot()`, supprimer :
+```rust
+// Supprimer ces deux lignes (ligne 555–556)
+let snapshot = self.queue_snapshot()?;
+let current_track_ids = self.track_ids()?;
+```
+
+Et utiliser directement les paramètres `snapshot` et `current_track_ids`.
+
+Appel depuis `sync_queue()` (ligne 1221) :
+```rust
+// Avant
+self.replace_queue_with_pivot(items, pivot_idx, playing_id)?;
+
+// Après — passer le snapshot et les IDs déjà disponibles
+let current_ids_for_pivot: Vec<u32> = snapshot.items
+    .iter()
+    .map(|i| i.backend_id as u32)
+    .collect();
+self.replace_queue_with_pivot(items, pivot_idx, playing_id, &snapshot, &current_ids_for_pivot)?;
+```
+
+**Note importante** : dans `sync_queue()`, le snapshot est pris APRÈS
+`ensure_playlist_source_selected()` (ligne 1115) et APRÈS la résolution du `playing_info`.
+Cet ordre est correct et doit être conservé.
+
+#### 2b. Passer le snapshot à `replace_queue_standard_lcs()`
+
+Signature actuelle (ligne 641) :
+```rust
+fn replace_queue_standard_lcs(
+    &mut self,
+    items: Vec<PlaybackItem>,
+    _current_index: Option<usize>,
+) -> Result<(), ControlPointError>
+```
+
+Nouvelle signature :
+```rust
+fn replace_queue_standard_lcs(
+    &mut self,
+    items: Vec<PlaybackItem>,
+    snapshot: &QueueSnapshot,           // ← ajouté
+    current_track_ids: &[u32],          // ← ajouté
+) -> Result<(), ControlPointError>
+```
+
+À l'intérieur, supprimer :
+```rust
+// Supprimer ces deux lignes (lignes 647–648)
+let snapshot = self.queue_snapshot()?;
+let current_track_ids = self.track_ids()?;
+```
+
+Appel depuis `sync_queue()` (ligne 1253) :
+```rust
+// Avant
+self.replace_queue_standard_lcs(items, Some(0))?;
+
+// Après
+let current_ids_for_lcs: Vec<u32> = snapshot.items
+    .iter()
+    .map(|i| i.backend_id as u32)
+    .collect();
+self.replace_queue_standard_lcs(items, &snapshot, &current_ids_for_lcs)?;
+```
+
+**Cas particulier à préserver** (ligne 1237–1246) : le guard sur `snapshot.items.is_empty()`
+dans `sync_queue()` est exécuté **avant** l'appel à `replace_queue_standard_lcs`, donc
+le snapshot vide ne peut pas atteindre la sous-fonction — le comportement est préservé.
+
+---
+
+### Étape 3 — Optimiser LCS par élagage du préfixe/suffixe communs
+
+**Fichier** : `pmocontrol/src/queue/openhome.rs`
+
+La fonction `lcs_flags()` (ligne 851) reste inchangée. L'optimisation s'applique
+**aux appels** dans `replace_queue_with_pivot()` et `replace_queue_standard_lcs()`.
+
+#### Principe
+
+Avant de calculer le LCS DP, éliminer les éléments identiques en tête et en queue :
+
+```rust
+/// Wrapper autour de lcs_flags() qui élimine préfixe et suffixe communs
+/// avant d'appeler l'algorithme DP O(m×n).
+/// 
+/// Cas optimisés : ajout en fin de liste → O(n), liste déjà synchro → O(n),
+/// suppression en fin → O(n). LCS complet uniquement pour les vrais réordonnements.
+fn lcs_flags_optimized(
+    current: &[PlaybackItem],
+    desired: &[PlaybackItem],
+) -> (Vec<bool>, Vec<bool>) {
+    // Préfixe commun
+    let leading = current
+        .iter()
+        .zip(desired.iter())
+        .take_while(|(c, d)| items_match(c, d))
+        .count();
+
+    // Suffixe commun (sur les portions restantes uniquement)
+    let c_tail = &current[leading..];
+    let d_tail = &desired[leading..];
+    let trailing = c_tail
+        .iter()
+        .rev()
+        .zip(d_tail.iter().rev())
+        .take_while(|(c, d)| items_match(c, d))
+        .count();
+
+    let c_mid = &c_tail[..c_tail.len() - trailing];
+    let d_mid = &d_tail[..d_tail.len() - trailing];
+
+    // Si rien à faire (listes identiques ou préfixe/suffixe couvrent tout)
+    if c_mid.is_empty() && d_mid.is_empty() {
+        return (vec![true; current.len()], vec![true; desired.len()]);
+    }
+
+    // LCS DP sur le delta central uniquement
+    let (keep_c_mid, keep_d_mid) = lcs_flags(c_mid, d_mid);
+
+    // Reconstituer les vecteurs complets
+    let mut keep_current = vec![true; leading];
+    keep_current.extend(keep_c_mid);
+    keep_current.extend(vec![true; trailing]);
+
+    let mut keep_desired = vec![true; leading];
+    keep_desired.extend(keep_d_mid);
+    keep_desired.extend(vec![true; trailing]);
+
+    (keep_current, keep_desired)
+}
+```
+
+Remplacer les 3 appels à `lcs_flags()` (lignes 579, 582, 661) par `lcs_flags_optimized()`.
+
+La fonction `lcs_flags()` originale est **conservée** (utilisée en interne par
+`lcs_flags_optimized()`).
+
+---
+
+### Étape 4 — Polling adaptatif selon l'activité
+
+**Fichier** : `pmocontrol/src/music_renderer/watcher.rs`
+
+Ajouter un flag partagé `is_active` dans `MusicRenderer` (ou `WatchedState`) pour
+signaler si le renderer est en activité récente.
+
+Le renderer met `is_active = true` lors de chaque opération (play, sync, seek, stop).
+Le watcher revient à l'intervalle long (5 000 ms) après 10 s sans activité.
+
+```rust
+// Dans la boucle du watcher :
+let interval = if is_active.load(Ordering::Relaxed) {
+    Duration::from_millis(500)
+} else {
+    Duration::from_millis(5_000)
+};
+thread::sleep(interval);
+```
+
+**Fonctionnalités à préserver** :
+- Détection de fin de piste (auto-advance) : délai max 5 s en idle — acceptable
+- Sleep timer countdown : reste actif au polling suivant
+- Synchronisation auto sur mise à jour de playlist : déclenchée par événement externe,
+  pas par le polling — non affectée
+
+---
+
+### Étape 5 — Consolider les redondances (nettoyage conservatif)
+
+**À réaliser uniquement après validation fonctionnelle des étapes 1–4.**
+
+#### 5a. Méthode `invalidate_all_caches()` sur `OpenHomeQueue`
+
+```rust
+fn invalidate_all_caches(&self) {
+    self.track_ids_cache.lock().unwrap().invalidate();
+    self.read_list_cache.lock().unwrap().invalidate();
+    self.current_track_id_cache.lock().unwrap().invalidate();
+}
+
+fn invalidate_track_caches(&self) {
+    self.track_ids_cache.lock().unwrap().invalidate();
+    self.read_list_cache.lock().unwrap().invalidate();
+}
+```
+
+Remplacer les séquences d'invalidation en 3 endroits (lignes 1134–1136, 454–456, 634–635).
+Garder les appels sélectifs là où seulement 2 caches sont invalidés.
+
+#### 5b. Factoriser `parse_duration()`
+
+Supprimer les définitions locales de `parse_duration` dans `openhome.rs` et `interne.rs`.
+Utiliser `crate::music_renderer::time_utils::parse_hhmmss_u32()` (déjà publique).
+La sémantique est identique : conversion `HH:MM:SS` → u64 secondes.
+
+#### 5c. Factoriser la protection durée stream
+
+Extraire la logique commune de protection (« ne jamais diminuer la durée d'un flux
+continu pour le même titre/artiste ») dans une fonction privée dans `openhome.rs`,
+et y référencer depuis `interne.rs` via le module `queue`.
+
+**Règle absolue** : ne pas modifier la sémantique de détection de stream continu
+(`is_continuous_stream_url()`) ni la logique de comparaison titre/artiste. Uniquement
+factoriser le code existant.
+
+---
+
+## Ordre d'exécution
+
+1. **Étape 1** — Batch ReadList 256 (changement trivial, gain immédiat −75 % appels)
+2. **Étape 2** — Élimination double `queue_snapshot()` (−50 % appels SOAP totaux)
+3. **Étape 3** — Optimisation LCS préfixe/suffixe (gain CPU, cas courants en O(n))
+4. **Étape 4** — Polling adaptatif (réduction contention réseau en veille)
+5. **Étape 5** — Consolidation redondances (nettoyage, après validation)
+
+## Périmètre : ce qui ne change pas
+
+- La logique à 3 cas de `sync_queue()` (avec pivot, préserver courant, LCS standard)
+- La protection durée décroissante pour les flux radio (cache stream)
+- Le mécanisme `delete_id_if_exists()` pour la robustesse multi-control-point
+- Le fallback `ReadList` one-by-one en cas d'erreur batch
+- La pagination Browse dans `control_point.rs` (déjà correcte)
+- Le comportement des queues `InternalQueue` (Chromecast, UPnP) — non affectées
+- Les TTL des caches existants (1 s, 500 ms, 250 ms)
+- Tous les logs de diagnostic (`tracing::warn!`, `debug!`) — à conserver
+
+## Tests recommandés
+
+Demander à l'humain de compiler et tester :
+
+```
+cargo build -p pmocontrol
+```
+
+Puis tester avec un renderer OpenHome physique :
+- Playlist de 1 000 titres : mesurer le temps de `sync_queue` avant/après
+- Ajout de titres en fin de liste : vérifier que LCS optimisé ne fait que des insertions
+- Lecture en cours + refresh playlist : vérifier que la piste courante n'est pas interrompue
+- Flux radio : vérifier que la durée ne régresse pas pour un même titre/artiste
+- Renderer Chromecast : vérifier l'absence de régression (queue interne)

Blackboard/Todo/enorme_playlist_step2.md

@@ -0,0 +1,235 @@
+# Optimisation Playlist OpenHome — Étape 2
+
+**Contexte**: Suite de `enorme_playlist.md`. Les optimisations de base (MAX_BATCH=256, LCS prefixe/suffixe, polling adaptatif, caches TTL) sont faites. Les lenteurs persistent sur les grandes playlists (~1000 titres). Les renderers Chromecast et UPnP sont moins affectés mais bénéficieront également de certaines optimisations.
+
+**Contrainte architecturale fondamentale**: La queue OpenHome est la **source de vérité unique**. Un miroir local persistent a été tenté et abandonné — impossible à maintenir en sync quand d'autres control points (BubbleUPnP, Linn, etc.) modifient la queue. Toute optimisation doit respecter cette contrainte.
+
+**Note sur le LCS**: `lcs_flags_optimized` (openhome.rs:869) gère déjà le cas dominant (préfixe/suffixe communs). Pour un append de 100 tracks à 900 existants, le LCS est O(1) — ce n'est pas le goulot. Le coût réel est les appels SOAP : connexions TCP × (RTT + handshake) et les `ReadList` pour reconstruire le snapshot.
+
+---
+
+## Analyse des Goulots Réels
+
+Pour un `sync_queue` "append 100 tracks à 900 existants" aujourd'hui :
+
+| Étape | Appels SOAP | Coût estimé |
+|-------|------------|-------------|
+| `id_array()` | 1 | ~5ms |
+| `read_list()` — 4 batches × 256 | 4 | ~20ms |
+| 100 × `insert()` | 100 | ~100 × (RTT + **TCP handshake**) |
+| **Total TCP handshakes** | 105 | **105 × 10-50ms = 1-5 secondes** |
+
+Les deux leviers : (1) éliminer les handshakes TCP, (2) éliminer les `ReadList` quand inutiles.
+
+---
+
+## Plan d'Implémentation
+
+### Phase 1 — Connection Pooling (1-2h, PRIORITÉ MAXIMALE)
+
+**Fichier**: `pmocontrol/src/soap_client.rs`
+
+**Problème**: lignes 65-72 créent un nouvel `ureq::Agent` à chaque appel SOAP = nouvelle connexion TCP à chaque fois.
+
+**Solution**: Agent statique partagé via `OnceLock`.
+
+```rust
+use std::sync::OnceLock;
+
+static SOAP_AGENT: OnceLock<ureq::Agent> = OnceLock::new();
+
+fn get_soap_agent() -> &'static ureq::Agent {
+    SOAP_AGENT.get_or_init(|| {
+        ureq::Agent::config_builder()
+            .http_status_as_error(false)
+            .timeout_global(Some(Duration::from_secs(30)))
+            .build()
+            .into()
+    })
+}
+```
+
+Dans `invoke_upnp_action_with_timeout()`, remplacer la construction de l'agent par :
+
+```rust
+// Cas normal : réutiliser l'agent partagé (keep-alive, connection pooling)
+// Cas custom timeout : agent dédié (rare — timeout global suffit en pratique)
+let agent_owned;
+let agent: &ureq::Agent = if timeout.is_some() {
+    agent_owned = ureq::Agent::config_builder()
+        .http_status_as_error(false)
+        .timeout_global(timeout)
+        .build()
+        .into();
+    &agent_owned
+} else {
+    get_soap_agent()
+};
+```
+
+**Vérifier** que `ureq::Agent` maintient bien un pool de connexions HTTP/1.1 keep-alive entre les appels (comportement documenté de ureq v3 — l'agent est conçu pour être réutilisé).
+
+**Impact**: Élimine les TCP handshakes répétés pour tous les renderers (OpenHome, UPnP, Chromecast). Pour 100 inserts : 99 handshakes économisés × 10-50ms = **1-5 secondes récupérées**.
+
+---
+
+### Phase 2 — Fast Path Session (2-3h, PRIORITÉ HAUTE)
+
+**Concept**: Sans miroir persistant (abandonné), on peut quand même éviter les `ReadList` dans le cas dominant en maintenant un état **éphémère de session** — valable uniquement entre deux `sync_queue` consécutifs, et invalidé dès qu'on détecte une incohérence.
+
+**Principe**: Après chaque `sync_queue`, mémoriser :
+- la liste d'IDs résultante (déjà dans `track_ids_cache` TTL 1s)
+- le `after_id` du dernier insert (pour pouvoir appender sans `id_array`)
+
+Au prochain `sync_queue`, tenter de détecter le pattern sans `ReadList` :
+
+```rust
+fn try_fast_path(&self, new_items: &[PlaybackItem]) -> FastPathResult {
+    // Récupérer les IDs actuels (cache ou 1 appel id_array)
+    let current_ids = self.track_ids()?;
+    let current_len = current_ids.len();
+    let new_len = new_items.len();
+
+    // Fast path 1: append only
+    // Condition: new_items a plus d'items, et les current_len premiers de new_items
+    // ont les mêmes didl_id que les items actuels (vérifiable depuis id_array + metadata_cache local)
+    if new_len > current_len {
+        let prefix_matches = self.check_prefix_matches(&current_ids, &new_items[..current_len]);
+        if prefix_matches {
+            return FastPathResult::AppendOnly { items: &new_items[current_len..] };
+        }
+    }
+
+    // Fast path 2: delete from end
+    if new_len < current_len {
+        let prefix_matches = self.check_prefix_matches(&current_ids[..new_len], new_items);
+        if prefix_matches {
+            let to_delete = &current_ids[new_len..];
+            return FastPathResult::DeleteFromEnd { ids: to_delete };
+        }
+    }
+
+    // Cas général: fallback ReadList + LCS
+    FastPathResult::NeedFullSync
+}
+```
+
+**`check_prefix_matches`** : compare `current_ids[i]` avec `new_items[i]` en utilisant le `metadata_cache` local (déjà en mémoire) pour résoudre les URIs/didl_ids des IDs connus. Si un ID n'est pas en cache → fast path impossible → fallback.
+
+**Clé**: Cette vérification utilise uniquement le `metadata_cache` local (HashMap en mémoire, nano-secondes) et `id_array()` (déjà caché TTL 1s). Zéro appel `ReadList` dans le cas heureux. Si la vérification échoue (incohérence détectée, cache manquant) → fallback propre vers `ReadList` + LCS, source de vérité OpenHome préservée.
+
+**Fichier**: `pmocontrol/src/queue/openhome.rs`, ajouter `try_fast_path()` et l'intégrer en début de `sync_queue()`.
+
+---
+
+### Phase 3 — Queue FIFO Async (8-12h, PRIORITÉ MOYENNE)
+
+**Prérequis**: Phases 1 et 2 complétées.
+
+**Concept**: Exécuter les opérations SOAP dans un thread dédié pour rendre `sync_queue()` non-bloquant du point de vue de l'appelant.
+
+**Contrainte technique**: Les `insert()` sont chaînés — chaque appel retourne un `new_id` utilisé comme `after_id` du suivant. Le worker doit maintenir cet état interne.
+
+**Fichier à créer**: `pmocontrol/src/queue/openhome_op_queue.rs`
+
+```rust
+pub enum OpenHomeOp {
+    /// Insert séquentiel — after_id géré en interne (last_inserted_id)
+    InsertAtEnd { uri: String, metadata: String, didl_id: String },
+    /// Insert après un ID connu (ex: après le pivot)
+    InsertAfter { after_id: u32, uri: String, metadata: String, didl_id: String },
+    DeleteId { track_id: u32 },
+    DeleteAll,
+    SeekId { id: u32 },
+    Play,
+    Pause,
+    Stop,
+    SetVolume { volume: u16 },
+}
+
+pub struct OpenHomeOpQueue {
+    sender: mpsc::Sender<OpenHomeOp>,
+    last_error: Arc<Mutex<Option<ControlPointError>>>,
+    completion: Arc<(Mutex<bool>, Condvar)>,
+}
+
+impl OpenHomeOpQueue {
+    pub fn push(&self, op: OpenHomeOp) { ... }
+    /// Opérations critiques passent devant (play/stop/volume)
+    pub fn push_priority(&self, op: OpenHomeOp) { ... }
+    /// Vider la file d'attente (ex: nouvelle playlist demandée avant fin de sync)
+    pub fn clear_pending(&self) { ... }
+    /// Attendre que toutes les opérations soient exécutées
+    pub fn wait_completion(&self) { ... }
+    /// Récupérer la dernière erreur (non-bloquant)
+    pub fn take_error(&self) -> Option<ControlPointError> { ... }
+}
+```
+
+**Comportement en cas d'erreur**: vider la file d'attente, signaler l'erreur via `last_error`, invalider les caches OpenHome (forcer re-sync depuis source de vérité au prochain appel).
+
+**Comportement en cas de `clear_pending()` pendant exécution**: laisser l'opération en cours se terminer (plus sûr — évite de laisser le renderer dans un état inconsistant), vider le reste.
+
+**Intégration dans `OpenHomeQueue`**: remplacer les appels directs `playlist_client.insert()` / `playlist_client.delete_id()` par des `op_queue.push()`. Les opérations qui ont besoin d'une réponse synchrone (ex: `current_track()`, `queue_snapshot()`) continuent d'appeler directement le `playlist_client` — mais doivent d'abord attendre la complétion de la file (`wait_completion()`).
+
+---
+
+### Phase 4 — Throttle des replace_item (2-3h, PRIORITÉ BASSE)
+
+**Contexte**: `replace_item()` (openhome.rs:1315) fait `delete_id` + `insert` pour mettre à jour une piste. Sur un stream radio qui change de morceau, la durée est mise à jour fréquemment → paires SOAP inutiles car le `metadata_cache` local est déjà la source pour l'UI.
+
+**Solution**: Ne pas envoyer le `delete_id` + `insert` OpenHome si une mise à jour pour ce `track_id` a déjà été envoyée dans les N dernières secondes. Le `metadata_cache` local est mis à jour immédiatement (pour l'UI), et l'opération OpenHome est différée ou ignorée.
+
+```rust
+fn replace_item(&mut self, index: usize, item: PlaybackItem) -> Result<(), ControlPointError> {
+    let track_id = self.track_ids()?[index];
+
+    // Toujours mettre à jour le cache local immédiatement (pour l'UI)
+    self.cache_metadata(track_id, item.metadata.clone());
+
+    // Throttle: si replace OpenHome récent pour ce track, sauter l'opération SOAP
+    if self.is_recent_replace(track_id, Duration::from_secs(5)) {
+        return Ok(());
+    }
+    self.mark_replace_time(track_id);
+
+    // Opération SOAP (delete + insert)
+    // ... code existant ...
+}
+```
+
+Ajouter `last_replace_times: Mutex<HashMap<u32, SystemTime>>` dans `OpenHomeQueue`.
+
+---
+
+## Ordre d'Implémentation
+
+```
+Phase 1 → mesurer gain TCP → Phase 2 → mesurer gain ReadList → Phase 3 → Phase 4
+```
+
+Tester chaque phase avec des playlists réelles (~1000 tracks) avant de poursuivre. Ne pas combiner les phases pour pouvoir isoler les régressions.
+
+## Tests
+
+```bash
+# Phase 1 — vérifier connexions TCP réutilisées
+# tcpdump -i lo port 60000 -c 200  (ou port du renderer)
+# Avant: SYN à chaque appel SOAP
+# Après: SYN unique, flux keep-alive
+
+# Phase 2 — vérifier fast path activé
+# RUST_LOG=debug cargo run ... 2>&1 | grep "fast path"
+# Cas append 100 → "fast path: AppendOnly, 100 inserts"
+# Cas delete 100 → "fast path: DeleteFromEnd, 100 deletes"
+# Cas reorder   → "fast path: NeedFullSync, falling back to ReadList+LCS"
+
+# Phase 3 — vérifier non-blocage
+# sync_queue() doit retourner en <1ms (les 100 inserts continuent en background)
+```
+
+---
+
+*Contrainte architecturale intégrée: miroir local abandonné (désynchronisation avec autres control points). Toutes les phases respectent OpenHome comme source de vérité unique.*
+
+*Date: 2026-04-08*

Blackboard/Todo/enorme_playlist_step3.md

@@ -0,0 +1,642 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+# Async Queue Refresh — Étape 3
+
+**Contexte**: `refresh_attached_queue_for()` dans `control_point.rs` est appelé de 3 endroits
+et bloque son thread pendant toute la synchronisation (browse media server + 100+ opérations
+SOAP/mémoire). L'objectif est de factoriser le mécanisme async au niveau de la couche queue
+(`MusicQueue`), qui est déjà l'abstraction agnostique du backend. `control_point.rs` ne doit
+plus connaître les threads ni les tokens d'annulation.
+
+**Principe architectural**: la couche queue sait *comment* syncer (mémoire ou SOAP) et donc
+aussi *comment* annuler et *quand* signaler que la lecture peut démarrer. `control_point.rs`
+sait seulement *quoi* syncer (browse + conversion PlaybackItem). Les deux responsabilités
+restent séparées.
+
+---
+
+## Vue d'ensemble des changements
+
+```
+AVANT
+  control_point.rs
+    refresh_attached_queue_for()
+      → browse()
+      → sync_queue(items)   ← bloquant 1-5s
+
+APRÈS
+  control_point.rs
+    do_queue_refresh_work()  ← interne, fait le browse + conversion
+  MusicQueue (couche queue)
+    schedule_sync(items, callbacks)  ← non-bloquant, retourne immédiatement
+      → thread "queue-sync-{renderer_id}"
+           → QueueBackend::sync_queue(items, cancel_token, on_ready)
+```
+
+---
+
+## Fichiers à modifier / créer
+
+| Fichier | Action |
+|---------|--------|
+| `pmocontrol/src/errors.rs` | Ajouter variante `SyncCancelled` |
+| `pmocontrol/src/queue/backend.rs` | Modifier signature `sync_queue()` |
+| `pmocontrol/src/queue/interne.rs` | Adapter signature `sync_queue()` |
+| `pmocontrol/src/queue/openhome.rs` | Adapter + points de vérification cancel + on_ready |
+| `pmocontrol/src/queue/music_queue.rs` | Ajouter champs async + méthode `schedule_sync()` |
+| `pmocontrol/src/queue/mod.rs` | Exporter `SyncScheduleOutcome` |
+| `pmocontrol/src/model.rs` | Ajouter événements `QueueReadyToPlay`, `QueueSyncCancelled` |
+| `pmocontrol/src/sse.rs` | Sérialiser les deux nouveaux événements |
+| `pmocontrol/src/control_point.rs` | Remplacer les 3 call sites bloquants |
+
+---
+
+## Étape 1 — Nouvelle variante d'erreur (`errors.rs`)
+
+**Fichier**: `pmocontrol/src/errors.rs`
+
+Ajouter après la ligne 51 (`ControlPoint`) :
+
+```rust
+#[error("Queue sync cancelled (superseded by a newer request)")]
+SyncCancelled,
+```
+
+Cette variante est retournée par `sync_queue()` quand le `cancel_token` passe à `true`.
+Elle est **non-fatale** — le coordinator la traite comme un comportement normal, pas une
+erreur à logger en `warn!`.
+
+---
+
+## Étape 2 — Modifier la signature de `sync_queue()` dans le trait (`backend.rs`)
+
+**Fichier**: `pmocontrol/src/queue/backend.rs`, ligne 110
+
+```rust
+// AVANT
+fn sync_queue(&mut self, items: Vec<PlaybackItem>) -> Result<(), ControlPointError>;
+
+// APRÈS
+use std::sync::{Arc, atomic::AtomicBool};
+
+fn sync_queue(
+    &mut self,
+    items: Vec<PlaybackItem>,
+    cancel_token: &Arc<AtomicBool>,
+    on_ready: Option<Box<dyn FnOnce() + Send>>,
+) -> Result<(), ControlPointError>;
+```
+
+**Sémantique des paramètres** :
+- `cancel_token` : si `true` au moment d'une opération, retourner `Err(SyncCancelled)` immédiatement
+- `on_ready` : callback one-shot appelé quand la lecture peut démarrer (voir logique ci-dessous)
+
+---
+
+## Étape 3 — Adapter `InternalQueue::sync_queue()` (`interne.rs`)
+
+**Fichier**: `pmocontrol/src/queue/interne.rs`
+
+Trouver la méthode `sync_queue()` et adapter la signature. Le corps reste identique,
+avec deux ajouts :
+
+**1. Vérification du pivot (early start)** : si une piste est en cours de lecture
+(un `current_index` est défini dans le snapshot courant), appeler `on_ready` immédiatement
+avant toute opération — la piste courante sera préservée.
+
+**2. Si pas de pivot** (queue vide ou aucune piste en cours) : appeler `on_ready` après
+avoir inséré le premier item.
+
+**3. Vérification cancel** : après chaque item inséré/supprimé (en pratique `InternalQueue`
+est rapide mais le principe doit être cohérent) :
+
+```rust
+fn sync_queue(
+    &mut self,
+    items: Vec<PlaybackItem>,
+    cancel_token: &Arc<AtomicBool>,
+    mut on_ready: Option<Box<dyn FnOnce() + Send>>,
+) -> Result<(), ControlPointError> {
+    use std::sync::atomic::Ordering::SeqCst;
+
+    // Early start si pivot présent
+    let has_current = self.current_index()?.is_some();
+    if has_current {
+        if let Some(f) = on_ready.take() { f(); }
+    }
+
+    // ... logique existante de sync_queue() ...
+    // Dans la boucle d'insertions, après le 1er insert :
+    if on_ready.is_some() {
+        if let Some(f) = on_ready.take() { f(); }
+    }
+    // Après chaque opération :
+    if cancel_token.load(SeqCst) {
+        return Err(ControlPointError::SyncCancelled);
+    }
+
+    Ok(())
+}
+```
+
+---
+
+## Étape 4 — Adapter `OpenHomeQueue::sync_queue()` (`openhome.rs`)
+
+**Fichier**: `pmocontrol/src/queue/openhome.rs`
+
+### 4.1 Signature (ligne ~1277)
+
+```rust
+fn sync_queue(
+    &mut self,
+    items: Vec<PlaybackItem>,
+    cancel_token: &Arc<AtomicBool>,
+    mut on_ready: Option<Box<dyn FnOnce() + Send>>,
+) -> Result<(), ControlPointError>
+```
+
+### 4.2 Early start — logique pivot
+
+Au début de `sync_queue()`, **avant** toute opération SOAP, détecter si un pivot est présent :
+
+```rust
+// Après la récupération du snapshot (ligne ~1323), avant les branches if/else :
+let has_pivot = playing_info.is_some();
+if has_pivot {
+    // Le pivot sera préservé — on peut démarrer la lecture immédiatement
+    if let Some(f) = on_ready.take() { f(); }
+}
+```
+
+Si pas de pivot (nouvelle playlist via `delete_all` + inserts depuis 0) : appeler `on_ready`
+après le **1er insert réussi** dans `replace_queue()` et dans `replace_queue_standard_lcs()`.
+
+### 4.3 Points de vérification cancel
+
+Ajouter `if cancel_token.load(SeqCst) { return Err(SyncCancelled); }` aux endroits suivants :
+
+- Dans `delete_marked_items()` (ligne ~458) : après chaque `delete_id_if_exists()`
+- Dans `rebuild_playlist_section()` (ligne ~494) : après chaque `insert()`
+- Dans `replace_queue_preserve_current()` (ligne ~419) : après chaque `delete_id_if_exists()` et `insert()`
+- Dans `replace_queue_standard_lcs()` (ligne ~693-745) : après chaque delete et insert
+- Dans `replace_queue()` (ligne ~1118) : après chaque insert dans la boucle
+- Dans le fast path `AppendOnly` (ligne ~1318) : après chaque insert
+- Dans le fast path `DeleteFromEnd` (ligne ~1336) : après chaque delete
+
+### 4.4 Propagation du cancel_token aux helpers
+
+Les méthodes helper privées qui font des boucles doivent recevoir le token :
+
+```rust
+fn delete_marked_items(
+    &mut self,
+    old_ids: &[u32],
+    keep_flags: &[bool],
+    position_label: &str,
+    cancel_token: &Arc<AtomicBool>,
+) -> Result<(), ControlPointError>
+
+fn rebuild_playlist_section(
+    &mut self,
+    // ... params existants ...
+    cancel_token: &Arc<AtomicBool>,
+    on_ready: &mut Option<Box<dyn FnOnce() + Send>>,
+) -> Result<u32, ControlPointError>
+```
+
+---
+
+## Étape 5 — Adapter `MusicQueue` (dispatch enum) (`music_queue.rs`)
+
+**Fichier**: `pmocontrol/src/queue/music_queue.rs`
+
+### 5.1 Adapter le dispatch `sync_queue()` (ligne ~98)
+
+```rust
+fn sync_queue(
+    &mut self,
+    items: Vec<PlaybackItem>,
+    cancel_token: &Arc<AtomicBool>,
+    on_ready: Option<Box<dyn FnOnce() + Send>>,
+) -> Result<(), ControlPointError> {
+    match self {
+        MusicQueue::Internal(q) => q.sync_queue(items, cancel_token, on_ready),
+        MusicQueue::OpenHome(q) => q.sync_queue(items, cancel_token, on_ready),
+    }
+}
+```
+
+### 5.2 Ajouter l'état async dans `MusicQueue`
+
+`MusicQueue` passe de simple enum de dispatch à une struct qui **encapsule** l'enum backend
+et l'état de synchronisation async :
+
+```rust
+// AVANT
+pub enum MusicQueue {
+    Internal(InternalQueue),
+    OpenHome(OpenHomeQueue),
+}
+
+// APRÈS
+pub struct MusicQueue {
+    backend: MusicQueueBackend,
+    // État async de synchronisation
+    sync_in_progress: Arc<AtomicBool>,
+    sync_pending: Arc<AtomicBool>,
+    sync_cancel_token: Arc<AtomicBool>,
+}
+
+// L'enum devient privée
+enum MusicQueueBackend {
+    Internal(InternalQueue),
+    OpenHome(OpenHomeQueue),
+}
+```
+
+**Note**: le changement de `enum` en `struct` implique de mettre à jour toutes les
+utilisations de `MusicQueue::Internal(...)` et `MusicQueue::OpenHome(...)` dans le reste
+du code (essentiellement `music_queue.rs` lui-même et `mod.rs`). Les callers externes
+utilisent `MusicQueue` via `QueueBackend` et `QueueFromRendererInfo` — ils ne sont pas
+impactés si l'API publique est préservée.
+
+### 5.3 Enum résultat et méthode `schedule_sync()`
+
+```rust
+pub enum SyncScheduleOutcome {
+    /// Thread spawné, sync en cours.
+    Scheduled,
+    /// Sync déjà en cours — annulée et nouvelle sync programmée en pending.
+    AlreadyRunning,
+}
+```
+
+```rust
+impl MusicQueue {
+    /// Lance une synchronisation asynchrone de la queue.
+    ///
+    /// - Si aucune sync n'est en cours : spawne un thread, retourne `Scheduled`.
+    /// - Si une sync est en cours : l'annule, note une sync pending, retourne `AlreadyRunning`.
+    ///   Le thread en cours finira l'opération courante, détectera le cancel, puis
+    ///   relancera la sync avec les nouveaux items via `pending_items_fn`.
+    ///
+    /// `pending_items_fn` : closure appelée dans le worker pour re-fetcher les items
+    ///   en cas de pending. Elle doit être Send + 'static car elle s'exécute dans un thread.
+    ///
+    /// `on_ready` : appelé dès que la lecture peut démarrer (pivot préservé ou 1er insert).
+    ///
+    /// `renderer_id` : utilisé uniquement pour nommer le thread de travail.
+    pub fn schedule_sync(
+        &self,  // &self car l'état async est derrière Arc<AtomicBool>
+        renderer_id: &str,
+        items: Vec<PlaybackItem>,
+        pending_items_fn: Box<dyn Fn() -> Result<Vec<PlaybackItem>, ControlPointError> + Send + 'static>,
+        on_ready: Option<Box<dyn FnOnce() + Send + 'static>>,
+    ) -> SyncScheduleOutcome
+```
+
+**Problème de `&mut self` vs `&self`** : `sync_queue()` dans le trait prend `&mut self`
+car les backends mutent leur état. Mais `schedule_sync()` veut spawner un thread qui détient
+le backend. Solution : le backend est déjà derrière `Arc<Mutex<MusicQueue>>` dans
+`MusicRenderer` (ligne 124 de musicrenderer.rs — c'est le `queue` field). Le thread worker
+clone cet `Arc` et acquiert le lock pour appeler `sync_queue()`.
+
+**Signature révisée** :
+
+```rust
+/// Doit être appelé avec un Arc<Mutex<Self>> pour permettre le spawn du thread worker.
+pub fn schedule_sync(
+    queue_arc: &Arc<Mutex<MusicQueue>>,
+    renderer_id: &str,
+    items: Vec<PlaybackItem>,
+    pending_items_fn: Box<dyn Fn() -> Result<Vec<PlaybackItem>, ControlPointError> + Send + 'static>,
+    on_ready: Option<Box<dyn FnOnce() + Send + 'static>>,
+) -> SyncScheduleOutcome {
+    use std::sync::atomic::Ordering::SeqCst;
+
+    let (sync_in_progress, sync_pending, sync_cancel_token) = {
+        let q = queue_arc.lock().unwrap();
+        (
+            Arc::clone(&q.sync_in_progress),
+            Arc::clone(&q.sync_pending),
+            Arc::clone(&q.sync_cancel_token),
+        )
+    };
+
+    if sync_in_progress.swap(true, SeqCst) {
+        // Sync en cours : annuler et noter pending
+        sync_cancel_token.store(true, SeqCst);
+        sync_pending.store(true, SeqCst);
+        return SyncScheduleOutcome::AlreadyRunning;
+    }
+
+    // Pas de sync en cours : initialiser et spawner
+    sync_cancel_token.store(false, SeqCst);
+    sync_pending.store(false, SeqCst);
+
+    let queue_arc = Arc::clone(queue_arc);
+    let thread_name = format!("queue-sync-{}", renderer_id);
+
+    thread::Builder::new()
+        .name(thread_name)
+        .spawn(move || {
+            // Guard: libère in_progress à la sortie même en cas de panic
+            struct Guard(Arc<AtomicBool>);
+            impl Drop for Guard {
+                fn drop(&mut self) { self.0.store(false, SeqCst); }
+            }
+            let _guard = Guard(Arc::clone(&sync_in_progress));
+
+            let mut current_items = items;
+            let mut current_on_ready = Some(on_ready);
+
+            loop {
+                sync_pending.store(false, SeqCst);
+                sync_cancel_token.store(false, SeqCst);
+
+                let result = {
+                    let mut q = queue_arc.lock().unwrap();
+                    q.backend.sync_queue(
+                        current_items,
+                        &sync_cancel_token,
+                        current_on_ready.take().flatten(),
+                    )
+                };
+
+                match result {
+                    Err(ControlPointError::SyncCancelled) => {
+                        // Annulé normalement — vérifier si pending
+                    }
+                    Err(e) => {
+                        warn!("queue-sync error: {}", e);
+                    }
+                    Ok(()) => {}
+                }
+
+                if !sync_pending.load(SeqCst) {
+                    break; // Pas de nouvelle sync en attente → terminer
+                }
+
+                // Nouvelle sync demandée pendant l'exécution → re-fetcher et relancer
+                match pending_items_fn() {
+                    Ok(new_items) => {
+                        current_items = new_items;
+                        current_on_ready = Some(None); // pas de on_ready pour les re-syncs
+                    }
+                    Err(e) => {
+                        warn!("queue-sync pending re-fetch error: {}", e);
+                        break;
+                    }
+                }
+            }
+            // _guard libère sync_in_progress = false
+        })
+        .expect("Failed to spawn queue-sync thread");
+
+    SyncScheduleOutcome::Scheduled
+}
+```
+
+---
+
+## Étape 6 — Nouveaux événements SSE
+
+### 6.1 `model.rs`
+
+Localiser l'enum `RendererEvent` et ajouter :
+
+```rust
+/// Émis dès que la queue peut être lue (pivot préservé ou 1er track inséré).
+QueueReadyToPlay {
+    id: DeviceId,
+},
+/// Émis quand une sync est annulée car une nouvelle a été demandée.
+QueueSyncCancelled {
+    id: DeviceId,
+},
+```
+
+### 6.2 `sse.rs`
+
+Localiser le match de sérialisation des `RendererEvent` et ajouter les deux variantes.
+Suivre le pattern existant de `QueueRefreshing` (ligne ~152) :
+
+```rust
+RendererEvent::QueueReadyToPlay { id } => {
+    // sérialiser avec type = "queue_ready_to_play"
+}
+RendererEvent::QueueSyncCancelled { id } => {
+    // sérialiser avec type = "queue_sync_cancelled"
+}
+```
+
+---
+
+## Étape 7 — Modifier `control_point.rs`
+
+### 7.1 Extraire la logique de browse
+
+Renommer `refresh_attached_queue_for()` en deux fonctions :
+
+**`fetch_queue_items_for()`** (nouvelle, interne) : fait le browse + conversion, retourne
+`Vec<PlaybackItem>`. C'est la `pending_items_fn` passée à `schedule_sync()`.
+
+**`schedule_queue_refresh_for()`** (remplace l'ancienne) : appelle `fetch_queue_items_for()`,
+puis `MusicQueue::schedule_sync()`.
+
+```rust
+fn fetch_queue_items_for(
+    registry: &Arc<RwLock<DeviceRegistry>>,
+    renderer_id: &DeviceId,
+) -> Result<Vec<PlaybackItem>, ControlPointError> {
+    // Browse media server + conversion PlaybackItem
+    // (logique actuellement dans refresh_attached_queue_for() lignes ~1593-1670)
+}
+
+fn schedule_queue_refresh_for(
+    registry: &Arc<RwLock<DeviceRegistry>>,
+    renderer_id: &DeviceId,
+    event_bus: &RendererEventBus,
+    auto_play_cb: Option<Box<dyn FnOnce(&DeviceId) -> Result<(), ControlPointError> + Send + 'static>>,
+) -> SyncScheduleOutcome {
+    let items = match fetch_queue_items_for(registry, renderer_id) {
+        Ok(items) => items,
+        Err(e) => { warn!(...); return SyncScheduleOutcome::Scheduled; /* ou erreur */ }
+    };
+
+    // on_ready : déclenche auto_play si demandé + émet QueueReadyToPlay SSE
+    let rid = renderer_id.clone();
+    let bus = event_bus.clone();
+    let on_ready: Option<Box<dyn FnOnce() + Send + 'static>> = Some(Box::new(move || {
+        bus.broadcast(RendererEvent::QueueReadyToPlay { id: rid.clone() });
+        if let Some(cb) = auto_play_cb {
+            if let Err(e) = cb(&rid) {
+                warn!("auto-play callback failed: {}", e);
+            }
+        }
+    }));
+
+    // pending_items_fn : re-fetcher depuis le media server si pending
+    let registry2 = Arc::clone(registry);
+    let rid2 = renderer_id.clone();
+    let pending_fn = Box::new(move || fetch_queue_items_for(&registry2, &rid2));
+
+    // Récupérer l'Arc<Mutex<MusicQueue>> du renderer depuis le registry
+    let queue_arc = {
+        let reg = registry.read().unwrap();
+        reg.get_renderer_queue_arc(renderer_id)? // méthode à ajouter dans DeviceRegistry
+    };
+
+    // Émettre QueueRefreshing avant de lancer
+    event_bus.broadcast(RendererEvent::QueueRefreshing { id: renderer_id.clone() });
+
+    let outcome = MusicQueue::schedule_sync(&queue_arc, &renderer_id.0, items, pending_fn, on_ready);
+
+    if matches!(outcome, SyncScheduleOutcome::AlreadyRunning) {
+        event_bus.broadcast(RendererEvent::QueueSyncCancelled { id: renderer_id.clone() });
+    }
+
+    outcome
+}
+```
+
+### 7.2 Call site 1 — thread "cp-media-server-event-worker" (l.270)
+
+```rust
+// AVANT
+let _ = refresh_attached_queue_for(&registry, &renderer_id, &event_bus, None);
+// APRÈS
+schedule_queue_refresh_for(&registry, &renderer_id, &event_bus, None);
+```
+
+### 7.3 Call site 2 — thread "cp-playlist-periodic-refresh" (l.340)
+
+```rust
+// AVANT
+let _ = refresh_attached_queue_for(&registry_for_periodic, &renderer_id, &event_bus_for_periodic, None);
+// APRÈS
+schedule_queue_refresh_for(&registry_for_periodic, &renderer_id, &event_bus_for_periodic, None);
+```
+
+### 7.4 Call site 3 — `attach_queue_to_playlist_async()` (l.1264)
+
+```rust
+pub async fn attach_queue_to_playlist_async(
+    &self, renderer_id: &DeviceId, server_id: &DeviceId, container_id: &str, auto_play: bool,
+) -> Result<(), ControlPointError> {
+    // 1. Enregistrer la liaison (synchrone, ~1ms)
+    self.registry.write().unwrap()
+        .set_playlist_binding(renderer_id, server_id, container_id);
+
+    // 2. Construire le callback auto-play si demandé
+    let cp = self.clone();
+    let rid = renderer_id.clone();
+    let auto_play_cb: Option<Box<dyn FnOnce(&DeviceId) -> Result<(), ControlPointError> + Send + 'static>> =
+        if auto_play {
+            Some(Box::new(move |id| cp.play_current_from_queue(id)))
+        } else {
+            None
+        };
+
+    // 3. Lancer le refresh async — retourne immédiatement
+    schedule_queue_refresh_for(&self.registry, renderer_id, &self.event_bus, auto_play_cb);
+
+    Ok(())  // La webapp sera notifiée via SSE (QueueRefreshing → QueueReadyToPlay → QueueUpdated)
+}
+```
+
+### 7.5 Fin de sync — émettre `QueueUpdated`
+
+L'événement `QueueUpdated` (avec `queue_length`) est actuellement émis à la ligne ~1718
+dans `refresh_attached_queue_for()`. Il doit être émis à la fin du worker thread dans
+`MusicQueue::schedule_sync()`, après le `sync_queue()` réussi.
+
+Passer un `on_complete` callback à `schedule_sync()` (en plus de `on_ready`) :
+
+```rust
+pub fn schedule_sync(
+    queue_arc: &Arc<Mutex<MusicQueue>>,
+    renderer_id: &str,
+    items: Vec<PlaybackItem>,
+    pending_items_fn: Box<dyn Fn() -> Result<Vec<PlaybackItem>, ControlPointError> + Send + 'static>,
+    on_ready: Option<Box<dyn FnOnce() + Send + 'static>>,
+    on_complete: Box<dyn Fn(usize) + Send + 'static>,  // NOUVEAU — reçoit queue_length
+) -> SyncScheduleOutcome
+```
+
+Dans le worker, après `Ok(())` du `sync_queue()` :
+
+```rust
+Ok(()) => {
+    let queue_len = queue_arc.lock().unwrap().len().unwrap_or(0);
+    on_complete(queue_len);
+}
+```
+
+Dans `schedule_queue_refresh_for()` :
+
+```rust
+let bus3 = event_bus.clone();
+let rid3 = renderer_id.clone();
+let on_complete = Box::new(move |queue_len: usize| {
+    bus3.broadcast(RendererEvent::QueueUpdated {
+        id: rid3.clone(),
+        queue_length: queue_len,
+    });
+});
+```
+
+---
+
+## Étape 8 — Accès à `Arc<Mutex<MusicQueue>>` depuis le registry
+
+`schedule_queue_refresh_for()` a besoin d'accéder à l'`Arc<Mutex<MusicQueue>>` du renderer.
+Localiser dans `DeviceRegistry` comment les renderers et leurs queues sont stockés, et ajouter
+une méthode :
+
+```rust
+pub fn get_renderer_queue_arc(
+    &self,
+    renderer_id: &DeviceId,
+) -> Result<Arc<Mutex<MusicQueue>>, ControlPointError>
+```
+
+(Ou équivalent selon la structure réelle du registry.)
+
+---
+
+## Ordre d'implémentation
+
+```
+Étape 1 (errors.rs)          ← 5 min
+Étape 2 (backend.rs)         ← 10 min, casse la compilation → à faire avant les autres
+Étape 3 (interne.rs)         ← 30 min
+Étape 4 (openhome.rs)        ← 1-2h (nombreux points de vérification cancel)
+Étape 5 (music_queue.rs)     ← 2-3h (changement struct + schedule_sync)
+Étape 6 (model.rs + sse.rs)  ← 30 min
+Étape 7 (control_point.rs)   ← 1h
+Étape 8 (registry)           ← 30 min selon la structure
+```
+
+Après l'étape 2, `cargo build` cassera jusqu'à l'étape 5 incluse — c'est attendu.
+Faire les étapes 3, 4, 5 dans la même session sans interrompre.
+
+## Tests
+
+```bash
+cargo build -p pmocontrol
+
+# Vérifier les scénarios :
+# 1. Attach playlist → QueueRefreshing SSE immédiat, QueueReadyToPlay après 1er insert,
+#    QueueUpdated après fin complète
+# 2. Attach 2e playlist pendant sync en cours → QueueSyncCancelled + nouveau refresh repart
+# 3. Piste en cours de lecture pendant sync → QueueReadyToPlay immédiat (pivot préservé)
+# 4. Refresh périodique (60s) ne bloque plus son thread
+
+RUST_LOG=debug cargo run 2>&1 | grep -E "queue.sync|SyncCancelled|Scheduled|AlreadyRunning|on_ready|on_complete"
+```
+
+---
+
+*Date: 2026-04-09*

Blackboard/Todo/frontend_enorme_playlist.md

@@ -0,0 +1,338 @@
+** Ce travail devra être réalisé en suivant scrupuleusement les consignes listées dans le fichier [@Rules_optimal.md](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/Blackboard/Rules_optimal.md) **
+
+## Contexte et symptôme
+
+Le frontend Vue.js du control point PMOMusic (`pmoapp/webapp`) présente des problèmes de
+performance significatifs avec des playlists de ~1000 titres. La plupart des lenteurs sont
+côté UI, indépendamment des optimisations déjà réalisées côté Rust/backend.
+
+Les trois manifestations observées :
+- **Freeze au scroll** dans la file d'attente (QueueViewer) dès ~200 items
+- **Blocage UI temporaire** à l'ouverture d'une playlist dans PlayListManager
+- **Refetches JSON répétés** déclenchés par les événements SSE `queue_updated`
+
+## Causes racines identifiées
+
+### P0 — Pas de virtualisation dans `QueueViewer.vue`
+
+**Fichier** : `src/components/pmocontrol/QueueViewer.vue:85-93`
+
+```vue
+<!-- Tous les items rendus en DOM simultanément -->
+<div v-if="queue?.items.length" class="queue-list" ref="queueContainer">
+    <QueueItem
+        v-for="item in queue.items"
+        :key="item.index"
+        ...
+    />
+</div>
+```
+
+Pour 1 000 titres : 1 000 nœuds DOM permanents, chacun contenant une image, un composable
+réactif (`useCoverImage`), et des computed properties. Le scroll devient impossible.
+
+**Ironie** : `vue-virtual-scroller@^2.0.0-beta.8` est présent dans `package.json` mais
+**n'est utilisé nulle part** dans la codebase — manifestement prévu puis abandonné.
+
+### P1 — Pas de virtualisation dans `PlayListManager.vue`
+
+**Fichier** : `src/components/PlayListManager.vue:562-724`
+
+```vue
+<div class="track-grid" v-if="sortedTracks.length > 0">
+    <article v-for="track in sortedTracks" :key="..." class="track-card">
+        <!-- image + title + artist + album + durée + bitrate + samplerate -->
+    </article>
+</div>
+```
+
+Même problème : grid CSS avec 1 000 articles et leurs images (`loading="lazy"`).
+
+Aggravé par la computed `sortedTracks` (ligne 883-890) :
+```typescript
+const sortedTracks = computed(() => {
+    return [...detail.tracks].sort(   // copie complète du tableau
+        (a, b) => new Date(b.added_at).getTime() - new Date(a.added_at).getTime()
+    );
+});
+```
+Et `lazyTracksCount` (ligne 892-897) qui filtre les 1 000 items à chaque re-render.
+
+### P2 — `queue_updated` force un refetch JSON complet
+
+**Fichier** : `src/composables/useRenderers.ts:200-206`
+
+```typescript
+case "queue_updated":
+    snapshot.state.queue_len = event.queue_length;
+    queueRefreshingIds.delete(rendererId);
+    // Pour la queue complète, on doit refetch
+    void fetchRendererSnapshot(rendererId, { force: true });
+    break;
+```
+
+`fetchRendererSnapshot()` appelle `api.getRendererFullSnapshot(rendererId)` qui retourne
+le snapshot complet incluant **tous les items de la queue avec leurs métadonnées**.
+
+Pour 1 000 titres, le payload JSON peut atteindre plusieurs centaines de Ko. Si l'utilisateur
+charge une playlist de 1 000 titres depuis un serveur qui émet les items par batch (ex. 64
+par 64 côté Rust), l'événement `queue_updated` est émis plusieurs fois de suite, déclenchant
+autant de refetches consécutifs du même JSON complet.
+
+**Note** : `loadingIds.has(rendererId)` (ligne 354) déduplique les requêtes simultanées,
+mais pas les requêtes consécutives rapprochées.
+
+### P3 — Infinite scroll accumule toutes les pages en mémoire (`MediaBrowser`)
+
+**Fichier** : `src/composables/useMediaServers.ts:200-204`
+
+```typescript
+// Accumuler les nouvelles entrées — jamais purgées
+state.entries.push(...data.entries)
+```
+
+En parcourant un serveur contenant 1 000 titres, toutes les pages de 50 items
+s'accumulent dans `browseCache` sans jamais être libérées. Résultat : après un scroll
+complet, 1 000 entrées sont en mémoire ET en DOM simultanément.
+
+### P4 — `scrollIntoView` sur 1 000 nœuds DOM non virtualisés
+
+**Fichier** : `src/components/pmocontrol/QueueViewer.vue:27-48`
+
+```typescript
+watch(() => queue.value?.current_index, async (currentIndex) => {
+    await nextTick();
+    const currentItem = queueContainer.value.querySelector(".queue-item.current");
+    if (currentItem) {
+        currentItem.scrollIntoView({ behavior: "smooth", block: "nearest" });
+    }
+}, { immediate: true });
+```
+
+`querySelector` sur un conteneur de 1 000 nœuds + animation CSS `smooth` provoque un
+layout thrashing. Ce watcher est aussi déclenché au montage (`immediate: true`), ce qui
+peut provoquer un re-layout au chargement initial de la page.
+
+## Ce qui fonctionne déjà correctement
+
+- **Déduplication des snapshots simultanés** : `loadingIds.has(rendererId)` évite les
+  requêtes parallèles pour le même renderer — à préserver.
+- **`loading="lazy"` sur les images** dans PlayListManager — efficace une fois que le DOM
+  est virtualisé.
+- **Cache du browse** avec invalidation par conteneur SSE — architecture correcte.
+- **`useCoverImage`** avec retry exponentiel et cleanup — à conserver tel quel dans
+  `QueueItem.vue`.
+- **Connexion SSE unique** partagée entre tous les composants — bonne architecture.
+
+## Plan d'exécution
+
+### Répertoire concerné : `pmoapp/webapp`
+
+---
+
+### Étape 1 — Virtualiser la file d'attente dans `QueueViewer.vue`
+
+**Fichier** : `src/components/pmocontrol/QueueViewer.vue`
+
+`vue-virtual-scroller` est déjà installé. Remplacer le `v-for` nu par `<RecycleScroller>` :
+
+```vue
+<script setup lang="ts">
+import { RecycleScroller } from 'vue-virtual-scroller';
+import 'vue-virtual-scroller/dist/vue-virtual-scroller.css';
+// ... imports existants inchangés
+</script>
+
+<template>
+    <!-- Remplacer le div.queue-list + v-for par : -->
+    <RecycleScroller
+        v-if="queue?.items.length"
+        class="queue-list"
+        :items="queue.items"
+        :item-size="64"
+        key-field="index"
+        v-slot="{ item }"
+        ref="queueContainer"
+    >
+        <QueueItem
+            :item="item"
+            :is-current="item.index === queue.current_index"
+            @click="handleItemClick"
+        />
+    </RecycleScroller>
+</template>
+```
+
+`item-size="64"` correspond à la hauteur CSS actuelle de `.queue-item` (padding +
+cover 48px + gap). À ajuster si le CSS change.
+
+**Adapter `scrollIntoView`** : `RecycleScroller` expose une méthode `scrollToItem(index)`.
+Remplacer le `querySelector` + `scrollIntoView` par :
+
+```typescript
+watch(() => queue.value?.current_index, async (currentIndex) => {
+    if (currentIndex !== null && currentIndex !== undefined && queueContainer.value) {
+        await nextTick();
+        queueContainer.value.scrollToItem(currentIndex);
+    }
+}, { immediate: true });
+```
+
+**Fonctionnalité préservée** : `QueueItem.vue` reste inchangé — `RecycleScroller` recycle
+les nœuds DOM au lieu de les créer tous, mais les props passées à chaque item sont
+identiques.
+
+---
+
+### Étape 2 — Débouncer les refetches `queue_updated`
+
+**Fichier** : `src/composables/useRenderers.ts:200-206`
+
+Le problème : `queue_updated` arrive N fois de suite pendant le chargement d'une grande
+playlist, déclenchant N refetches.
+
+Ajouter un debounce par renderer sur l'appel à `fetchRendererSnapshot` :
+
+```typescript
+// Map des timers de debounce par renderer (à déclarer en module scope)
+const queueUpdateDebounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+const QUEUE_UPDATE_DEBOUNCE_MS = 300;
+
+// Dans le case "queue_updated" :
+case "queue_updated":
+    snapshot.state.queue_len = event.queue_length;
+    queueRefreshingIds.delete(rendererId);
+
+    // Annuler le timer précédent pour ce renderer
+    const existingTimer = queueUpdateDebounceTimers.get(rendererId);
+    if (existingTimer) clearTimeout(existingTimer);
+
+    // Programmer un seul fetch après stabilisation
+    queueUpdateDebounceTimers.set(rendererId, setTimeout(() => {
+        queueUpdateDebounceTimers.delete(rendererId);
+        void fetchRendererSnapshot(rendererId, { force: true });
+    }, QUEUE_UPDATE_DEBOUNCE_MS));
+    break;
+```
+
+**Fonctionnalité préservée** : Si un seul `queue_updated` arrive (cas normal), le refetch
+est simplement retardé de 300 ms — imperceptible. Si N arrivent en rafale (chargement
+d'une grande playlist), un seul refetch est déclenché à la fin.
+
+**Contrainte** : Ne pas dépasser 500 ms de debounce — l'indicateur `queueRefreshing` dans
+l'UI doit se désactiver rapidement après la fin du chargement.
+
+---
+
+### Étape 3 — Virtualiser la grille dans `PlayListManager.vue`
+
+**Fichier** : `src/components/PlayListManager.vue`
+
+La grille CSS ne peut pas être virtualisée directement avec `RecycleScroller` (liste 1D).
+Remplacer la grid par une liste virtualisée, ou introduire une pagination côté client :
+
+```typescript
+const PAGE_SIZE = 100;
+const currentPage = ref(0);
+
+const paginatedTracks = computed(() =>
+    sortedTracks.value.slice(
+        currentPage.value * PAGE_SIZE,
+        (currentPage.value + 1) * PAGE_SIZE
+    )
+);
+```
+
+Avec des boutons de navigation Précédent / Suivant et un indicateur de page.
+
+**Optimiser `sortedTracks`** : mémoriser le résultat par `playlist.id` pour éviter
+la copie+tri à chaque re-render non lié à la playlist :
+
+```typescript
+const sortedTracksCache = new Map<string, TrackEntry[]>();
+
+const sortedTracks = computed(() => {
+    const detail = selectedPlaylist.value;
+    if (!detail) return [];
+    const cached = sortedTracksCache.get(detail.id);
+    if (cached && cached.length === detail.tracks.length) return cached;
+    const sorted = [...detail.tracks].sort(
+        (a, b) => new Date(b.added_at).getTime() - new Date(a.added_at).getTime()
+    );
+    sortedTracksCache.set(detail.id, sorted);
+    return sorted;
+});
+```
+
+**Simplifier `lazyTracksCount`** : le dériver de `sortedTracks` pour ne pas parcourir
+le tableau original en parallèle :
+
+```typescript
+const lazyTracksCount = computed(() =>
+    sortedTracks.value.filter(isLazyTrack).length
+);
+```
+
+---
+
+### Étape 4 — Limiter l'accumulation dans le browse infini (`MediaBrowser`)
+
+**Fichier** : `src/composables/useMediaServers.ts:183-212`
+
+Implémenter une fenêtre glissante dans `browseCache` : conserver seulement les 200
+derniers items en mémoire :
+
+```typescript
+const BROWSE_WINDOW_SIZE = 200;
+
+async function loadMoreBrowse(serverId: string, containerId: string) {
+    // ... code existant jusqu'à la récupération de data ...
+
+    // Remplacer : state.entries.push(...data.entries)
+    // Par :
+    const combined = [...state.entries, ...data.entries];
+    state.entries = combined.slice(-BROWSE_WINDOW_SIZE);
+    state.total_count = data.total_count;
+    state.currentOffset = (state.currentOffset ?? 0) + data.entries.length;
+    state.hasMore = state.currentOffset < state.total_count;
+    browseCache.value.set(key, { ...state });
+}
+```
+
+**Invariant à préserver** : `state.currentOffset` et `state.hasMore` doivent continuer
+de refléter la position réelle dans la liste serveur, indépendamment de ce qui est
+affiché — leur logique ne change pas.
+
+---
+
+## Ordre d'exécution
+
+1. **Étape 1** — Virtualisation `QueueViewer` (impact le plus visible, composant le plus simple)
+2. **Étape 2** — Debounce `queue_updated` (élimine les refetches en cascade, changement minimal)
+3. **Étape 3** — Optimisation `PlayListManager` (plus complexe, composant de 2039 lignes)
+4. **Étape 4** — Fenêtre glissante `MediaBrowser` (amélioration mémoire, moins critique)
+
+## Périmètre : ce qui ne change pas
+
+- `QueueItem.vue` : aucune modification (recycling géré par le parent)
+- `useCoverImage.ts` : aucune modification (lazy loading + retry déjà corrects)
+- `useSSE.ts` : aucune modification (connexion unique, bonne architecture)
+- `loadingIds` dans `fetchRendererSnapshot` : déduplication conservée
+- `api.getRendererFullSnapshot` : le payload reste complet, pas de pagination API
+- Tous les événements SSE autres que `queue_updated` : aucune modification
+
+## Tests recommandés
+
+Demander à l'humain de :
+
+```bash
+cd pmoapp/webapp
+npm run dev
+```
+
+Puis tester manuellement :
+- Ouvrir la file d'attente d'un renderer OpenHome avec 1 000 titres : scroll fluide ?
+- Vérifier que la piste courante est visible au changement de piste (`scrollToItem`)
+- Charger une playlist de 1 000 titres via PlayListManager : absence de blocage ?
+- Observer les requêtes réseau dans DevTools lors du chargement d'une grande playlist :
+  un seul `GET /renderers/{id}/full` doit être émis après la fin du chargement

Blackboard/Todo/mdns_sd_migration.md

@@ -0,0 +1,306 @@
+# Migration `mdns` → `mdns-sd`
+
+## Contexte
+
+La crate `mdns 3.0.0` (dernière version, 2021, abandonnée) s'appuie sur `dns-parser 0.8.0`
+qui rejette les labels DNS non-ASCII avec `LabelIsNotAscii`. Les appareils Apple utilisent
+U+2019 (RIGHT SINGLE QUOTATION MARK) dans leurs noms (ex : "Sophie's MacBook Air"), ce qui
+spamme les logs en WARN à chaque paquet mDNS reçu.
+
+`mdns-sd 0.19` (avril 2026, activement maintenu) gère l'UTF-8 correctement, fournit une API
+de plus haut niveau (service pré-assemblé), et ne nécessite pas `async-std`.
+
+## Périmètre
+
+Deux fichiers à modifier, un fichier à nettoyer :
+
+| Fichier | Rôle |
+|---|---|
+| `pmocontrol/Cargo.toml` | Dépendances |
+| `pmocontrol/src/control_point.rs` | Thread de découverte mDNS (lignes 145–195) |
+| `pmocontrol/src/discovery/chromecast_discovery.rs` | Parsing des réponses mDNS |
+| `pmoserver/src/logs/mod.rs` | Filtre de bruit `mdns=error` devenu inutile |
+
+---
+
+## Étape 1 — `pmocontrol/Cargo.toml`
+
+### Supprimer
+```toml
+mdns = "3.0"
+```
+
+Vérifier si `async-std` et `futures-util` sont utilisés **ailleurs** que dans le thread mDNS.
+D'après l'analyse :
+- `async_std` : uniquement `control_point.rs:161` → **supprimer**
+- `futures-util` : uniquement `control_point.rs:150,167` → **supprimer**
+
+### Ajouter
+```toml
+mdns-sd = "0.19"
+```
+
+---
+
+## Étape 2 — `pmocontrol/src/control_point.rs`
+
+### Code actuel (lignes 145–195) à remplacer intégralement
+
+```rust
+// Thread de découverte mDNS pour Chromecast
+let registry_for_mdns = Arc::clone(&registry);
+let udn_cache_for_mdns = Arc::clone(&udn_cache);
+thread::spawn(move || {
+    use crate::discovery::ChromecastDiscoveryManager;
+    use futures_util::StreamExt;
+
+    let mut discovery_manager =
+        ChromecastDiscoveryManager::new(registry_for_mdns, udn_cache_for_mdns);
+
+    debug!("Starting mDNS discovery thread for Chromecast devices");
+
+    const SERVICE_NAME: &str = "_googlecast._tcp.local";
+
+    async_std::task::block_on(async {
+        match mdns::discover::all(SERVICE_NAME, Duration::from_secs(15)) {
+            Ok(discovery) => {
+                let stream = discovery.listen();
+                futures_util::pin_mut!(stream);
+                debug!("mDNS discovery stream started for Chromecast devices");
+                while let Some(result) = stream.next().await {
+                    match result {
+                        Ok(response) => {
+                            debug!("Received mDNS response with {} records", response.records().count());
+                            discovery_manager.handle_mdns_response(response);
+                        }
+                        Err(e) => { warn!("mDNS discovery error: {}", e); }
+                    }
+                }
+                warn!("mDNS discovery stream ended unexpectedly");
+            }
+            Err(e) => { error!("Failed to start mDNS discovery: {}", e); }
+        }
+    });
+});
+```
+
+### Nouveau code
+
+```rust
+// Thread de découverte mDNS pour Chromecast
+let registry_for_mdns = Arc::clone(&registry);
+let udn_cache_for_mdns = Arc::clone(&udn_cache);
+thread::spawn(move || {
+    use crate::discovery::ChromecastDiscoveryManager;
+    use mdns_sd::{ServiceDaemon, ServiceEvent};
+
+    let mut discovery_manager =
+        ChromecastDiscoveryManager::new(registry_for_mdns, udn_cache_for_mdns);
+
+    debug!("Starting mDNS discovery thread for Chromecast devices");
+
+    // Note: mdns-sd requires the trailing dot in the service type
+    const SERVICE_TYPE: &str = "_googlecast._tcp.local.";
+
+    let daemon = match ServiceDaemon::new() {
+        Ok(d) => d,
+        Err(e) => {
+            error!("Failed to create mDNS daemon: {}", e);
+            return;
+        }
+    };
+
+    let receiver = match daemon.browse(SERVICE_TYPE) {
+        Ok(r) => r,
+        Err(e) => {
+            error!("Failed to start mDNS browse for {}: {}", SERVICE_TYPE, e);
+            return;
+        }
+    };
+
+    debug!("mDNS discovery started for Chromecast devices");
+
+    while let Ok(event) = receiver.recv() {
+        match event {
+            ServiceEvent::ServiceResolved(info) => {
+                debug!(
+                    fullname = info.get_fullname(),
+                    host = info.get_hostname(),
+                    port = info.get_port(),
+                    "mDNS Chromecast service resolved"
+                );
+                discovery_manager.handle_service_resolved(&info);
+            }
+            ServiceEvent::ServiceRemoved(_service_type, fullname) => {
+                debug!(fullname = %fullname, "mDNS Chromecast service removed");
+                // Pas de retrait actif du registre : le timeout habituel s'en charge
+            }
+            _ => {}
+        }
+    }
+
+    warn!("mDNS discovery receiver closed");
+});
+```
+
+### Points d'attention
+- Le point final `.` dans `"_googlecast._tcp.local."` est **obligatoire** pour `mdns-sd`.
+- `receiver.recv()` est bloquant synchrone — pas besoin d'async runtime.
+- `ServiceDaemon` gère son propre thread interne ; inutile de relancer manuellement.
+
+---
+
+## Étape 3 — `pmocontrol/src/discovery/chromecast_discovery.rs`
+
+### Supprimer l'import `mdns`
+
+```rust
+// Supprimer ces uses implicites via le type dans la signature
+use std::collections::HashMap;  // <- plus nécessaire si on passe par TxtProperties
+```
+
+### Ajouter l'import `mdns-sd`
+
+```rust
+use mdns_sd::ServiceInfo;
+```
+
+### Remplacer `handle_mdns_response` par `handle_service_resolved`
+
+#### Code actuel (lignes 39–179) — ~80 lignes de parsing manuel
+
+Toute la logique d'extraction PTR / A / AAAA / SRV / TXT disparaît.
+
+#### Nouveau code
+
+```rust
+/// Traite un service Chromecast résolu par mDNS-SD.
+///
+/// `ServiceInfo` arrive pré-assemblé : plus besoin de jointure manuelle
+/// des enregistrements PTR / A / SRV / TXT.
+pub fn handle_service_resolved(&mut self, info: &ServiceInfo) {
+    let fullname = info.get_fullname().to_string();
+
+    debug!("Processing resolved Chromecast service: {}", fullname);
+
+    // Adresse IP : préférer IPv4
+    let host = match info
+        .get_addresses()
+        .iter()
+        .find(|a| a.is_ipv4())
+        .or_else(|| info.get_addresses().iter().next())
+    {
+        Some(addr) => addr.to_string(),
+        None => {
+            warn!("No IP address for Chromecast service: {}", fullname);
+            return;
+        }
+    };
+
+    let port = info.get_port();
+
+    // TXT records — API directe par clé
+    let uuid = info
+        .get_property_val_str("id")
+        .unwrap_or_default()
+        .to_string();
+    let uuid = if uuid.is_empty() {
+        format!("chromecast-{}-{}", host, port)
+    } else {
+        uuid
+    };
+
+    let model = info.get_property_val_str("md").map(|s| s.to_string());
+
+    let friendly_name = info
+        .get_property_val_str("fn")
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| {
+            // Fallback : extraire depuis le fullname, supprimer le suffixe de service
+            fullname
+                .split("._googlecast._tcp.local")
+                .next()
+                .unwrap_or("Unknown Chromecast")
+                .split('-')
+                .take_while(|part| part.len() != 32)
+                .collect::<Vec<_>>()
+                .join("-")
+                .trim()
+                .to_string()
+        });
+
+    debug!(
+        "Discovered Chromecast: {} at {}:{} (UUID: {}, Model: {:?})",
+        friendly_name, host, port, uuid, model
+    );
+
+    let udn = format!("uuid:{}", uuid);
+    let default_max_age = 1800u64;
+
+    if !UDNRegistry::should_fetch(self.udn_cache.clone(), &udn, default_max_age) {
+        debug!("Chromecast {} recently seen, skipping", udn);
+        return;
+    }
+
+    let renderer_info = build_renderer_info(
+        &uuid,
+        &friendly_name,
+        &host,
+        port,
+        model.as_deref(),
+        Some("Google Inc."),
+    );
+
+    self.device_registry
+        .write()
+        .expect("DeviceRegistry mutex lock failed")
+        .push_renderer(&renderer_info, default_max_age as u32);
+}
+```
+
+### Supprimer
+- L'import `use std::collections::HashMap` (plus utilisé)
+- Tout le bloc `handle_mdns_response` (lignes 39–179)
+
+### Conserver sans modification
+- `build_renderer_info` (lignes 182–234)
+- `extract_host_from_location` / `extract_port_from_location` (lignes 239–258)
+- Les tests (lignes 260–287)
+
+---
+
+## Étape 4 — `pmoserver/src/logs/mod.rs`
+
+Le filtre de bruit `mdns=error` injecté dans `build_filter_with_noise_suppressions` n'est
+plus nécessaire. Deux options :
+
+**Option A (recommandée)** — Supprimer l'entrée du tableau :
+```rust
+const NOISE_FILTERS: &[(&str, &str)] = &[
+    // ("mdns", "mdns=error"),  // supprimé : migration vers mdns-sd
+];
+```
+Ou supprimer `build_filter_with_noise_suppressions` entièrement si aucun autre bruit n'est
+à filtrer, et revenir à `EnvFilter::try_new(base)` direct.
+
+**Option B** — Laisser en place. La directive `mdns=error` ne cause aucun dommage si la
+crate `mdns` n'est plus dans le build (elle sera simplement ignorée).
+
+---
+
+## Résumé des diffs
+
+| Fichier | Lignes supprimées | Lignes ajoutées |
+|---|---|---|
+| `Cargo.toml` | `mdns`, `async-std`, `futures-util` | `mdns-sd` |
+| `control_point.rs` | ~50 (async block) | ~35 (sync recv loop) |
+| `chromecast_discovery.rs` | ~80 (parsing manuel) | ~50 (lecture ServiceInfo) |
+| `logs/mod.rs` | ~5 (filtre bruit) | 0 |
+
+## Vérification
+
+Après implémentation :
+1. `cargo check -p pmocontrol` sans erreurs ni `use of undeclared crate mdns`
+2. `cargo check -p pmoserver` sans erreurs
+3. Tester la découverte d'un Chromecast en réseau local
+4. Vérifier l'absence de `LabelIsNotAscii` dans les logs avec des appareils Apple présents

Blackboard_HTML/Architecture_music_source.html

@@ -0,0 +1,934 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>music_source</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1 id="guide-dimplémentation-dune-nouvelle-musicsource">Guide
+d’implémentation d’une nouvelle MusicSource</h1>
+<p>Ce document décrit comment implémenter une nouvelle source musicale
+dans l’écosystème PMOMusic en suivant le trait <code>MusicSource</code>
+défini dans le crate <code>pmosource</code>.</p>
+<h2 id="table-des-matières">Table des matières</h2>
+<ol type="1">
+<li><a href="#vue-densemble">Vue d’ensemble</a></li>
+<li><a href="#structure-dune-musicsource">Structure d’une
+MusicSource</a></li>
+<li><a href="#implémentation-du-trait-musicsource">Implémentation du
+trait MusicSource</a></li>
+<li><a href="#patterns-dimplémentation">Patterns
+d’implémentation</a></li>
+<li><a href="#intégration-avec-lécosystème-pmomusic">Intégration avec
+l’écosystème PMOMusic</a></li>
+<li><a href="#checklist-de-mise-en-œuvre">Checklist de mise en
+œuvre</a></li>
+<li><a href="#exemples-de-référence">Exemples de référence</a></li>
+</ol>
+<h2 id="vue-densemble">Vue d’ensemble</h2>
+<p>Une <code>MusicSource</code> est une abstraction qui représente une
+source de contenu musical dans PMOMusic. Elle peut être :</p>
+<ul>
+<li><strong>Dynamique (FIFO)</strong> : Radio Paradise, streaming radio,
+playlists live</li>
+<li><strong>Statique</strong> : Albums Qobuz, bibliothèque locale,
+playlists fixes</li>
+</ul>
+<p>Le trait <code>MusicSource</code> définit une interface unifiée pour
+: - La navigation UPnP ContentDirectory (browse) - La résolution d’URI
+audio (avec cache) - La gestion de playlists FIFO (pour les sources
+dynamiques) - Le suivi des changements (update_id, last_change)</p>
+<h2 id="structure-dune-musicsource">Structure d’une MusicSource</h2>
+<h3 id="organisation-du-code">Organisation du code</h3>
+<pre><code>pmo&lt;votre-source&gt;/
+├── src/
+│   ├── lib.rs              # Exports publics
+│   ├── source.rs           # Implémentation MusicSource
+│   ├── client.rs           # Client API (optionnel)
+│   ├── models.rs           # Structures de données
+│   ├── config.rs           # Configuration
+│   └── didl.rs             # Conversion DIDL-Lite (optionnel)
+├── assets/
+│   └── default.webp        # Logo 300x300px
+├── Cargo.toml
+└── README.md</pre>
+<h3 id="dépendances-principales">Dépendances principales</h3>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode toml"><code class="sourceCode toml"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">[dependencies]</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a><span class="dt">pmosource</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">path</span><span class="op"> =</span> <span class="st">&quot;../pmosource&quot;</span><span class="op"> }</span></span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a><span class="dt">pmodidl</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">path</span><span class="op"> =</span> <span class="st">&quot;../pmodidl&quot;</span><span class="op"> }</span></span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a><span class="dt">pmoplaylist</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">path</span><span class="op"> =</span> <span class="st">&quot;../pmoplaylist&quot;</span><span class="op">, </span><span class="dt">optional</span><span class="op"> =</span> <span class="cn">true</span><span class="op"> }</span>  <span class="co"># Si FIFO</span></span>
+<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a><span class="dt">pmoaudiocache</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">path</span><span class="op"> =</span> <span class="st">&quot;../pmoaudiocache&quot;</span><span class="op">, </span><span class="dt">optional</span><span class="op"> =</span> <span class="cn">true</span><span class="op"> }</span>  <span class="co"># Si cache</span></span>
+<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a><span class="dt">pmocovers</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">path</span><span class="op"> =</span> <span class="st">&quot;../pmocovers&quot;</span><span class="op">, </span><span class="dt">optional</span><span class="op"> =</span> <span class="cn">true</span><span class="op"> }</span>  <span class="co"># Si cache</span></span>
+<span id="cb2-7"><a href="#cb2-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb2-8"><a href="#cb2-8" aria-hidden="true" tabindex="-1"></a><span class="dt">async-trait</span> <span class="op">=</span> <span class="st">&quot;0.1&quot;</span></span>
+<span id="cb2-9"><a href="#cb2-9" aria-hidden="true" tabindex="-1"></a><span class="dt">tokio</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">version</span><span class="op"> =</span> <span class="st">&quot;1&quot;</span><span class="op">, </span><span class="dt">features</span><span class="op"> =</span> <span class="op">[</span><span class="st">&quot;sync&quot;</span><span class="op">] }</span></span>
+<span id="cb2-10"><a href="#cb2-10" aria-hidden="true" tabindex="-1"></a><span class="dt">serde</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">version</span><span class="op"> =</span> <span class="st">&quot;1&quot;</span><span class="op">, </span><span class="dt">features</span><span class="op"> =</span> <span class="op">[</span><span class="st">&quot;derive&quot;</span><span class="op">] }</span></span>
+<span id="cb2-11"><a href="#cb2-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb2-12"><a href="#cb2-12" aria-hidden="true" tabindex="-1"></a><span class="kw">[features]</span></span>
+<span id="cb2-13"><a href="#cb2-13" aria-hidden="true" tabindex="-1"></a><span class="dt">default</span> <span class="op">=</span> <span class="op">[</span><span class="st">&quot;cache&quot;</span><span class="op">]</span></span>
+<span id="cb2-14"><a href="#cb2-14" aria-hidden="true" tabindex="-1"></a><span class="dt">cache</span> <span class="op">=</span> <span class="op">[</span><span class="st">&quot;pmoaudiocache&quot;</span><span class="op">,</span> <span class="st">&quot;pmocovers&quot;</span><span class="op">]</span></span>
+<span id="cb2-15"><a href="#cb2-15" aria-hidden="true" tabindex="-1"></a><span class="dt">playlist</span> <span class="op">=</span> <span class="op">[</span><span class="st">&quot;pmoplaylist&quot;</span><span class="op">]</span></span></pre></div>
+<h2 id="implémentation-du-trait-musicsource">Implémentation du trait
+MusicSource</h2>
+<h3 id="informations-de-base">1. Informations de base</h3>
+<p>Chaque source doit fournir :</p>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmosource::</span><span class="op">{</span>async_trait<span class="op">,</span> MusicSource<span class="op">};</span></span>
+<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Clone</span><span class="op">,</span> <span class="bu">Debug</span><span class="at">)]</span></span>
+<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> MyMusicSource <span class="op">{</span></span>
+<span id="cb3-5"><a href="#cb3-5" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Champs internes</span></span>
+<span id="cb3-6"><a href="#cb3-6" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb3-7"><a href="#cb3-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-8"><a href="#cb3-8" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb3-9"><a href="#cb3-9" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> MusicSource <span class="cf">for</span> MyMusicSource <span class="op">{</span></span>
+<span id="cb3-10"><a href="#cb3-10" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> name(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="op">&amp;</span><span class="dt">str</span> <span class="op">{</span></span>
+<span id="cb3-11"><a href="#cb3-11" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ma Source Musicale&quot;</span>  <span class="co">// Nom affiché dans l&#39;UI</span></span>
+<span id="cb3-12"><a href="#cb3-12" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb3-13"><a href="#cb3-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-14"><a href="#cb3-14" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> id(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="op">&amp;</span><span class="dt">str</span> <span class="op">{</span></span>
+<span id="cb3-15"><a href="#cb3-15" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;my-music-source&quot;</span>  <span class="co">// ID unique (format: lowercase-kebab-case)</span></span>
+<span id="cb3-16"><a href="#cb3-16" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb3-17"><a href="#cb3-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-18"><a href="#cb3-18" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> default_image(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="op">&amp;</span>[<span class="dt">u8</span>] <span class="op">{</span></span>
+<span id="cb3-19"><a href="#cb3-19" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Logo WebP 300x300px inclus dans le binaire</span></span>
+<span id="cb3-20"><a href="#cb3-20" aria-hidden="true" tabindex="-1"></a>        <span class="pp">include_bytes!</span>(<span class="st">&quot;../assets/default.webp&quot;</span>)</span>
+<span id="cb3-21"><a href="#cb3-21" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb3-22"><a href="#cb3-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-23"><a href="#cb3-23" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> default_image_mime_type(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="op">&amp;</span><span class="dt">str</span> <span class="op">{</span></span>
+<span id="cb3-24"><a href="#cb3-24" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;image/webp&quot;</span>  <span class="co">// Toujours WebP</span></span>
+<span id="cb3-25"><a href="#cb3-25" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb3-26"><a href="#cb3-26" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Règles :</strong> - <code>id()</code> doit être unique parmi
+toutes les sources - <code>id()</code> doit être en lowercase-kebab-case
+- <code>default_image()</code> doit être un WebP 300x300px</p>
+<h3 id="navigation-contentdirectory">2. Navigation ContentDirectory</h3>
+<h4 id="container-racine">2.1 Container racine</h4>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> root_container(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Container<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>(Container <span class="op">{</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a>        id<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>id()<span class="op">.</span>to_string()<span class="op">,</span>  <span class="co">// &quot;my-music-source&quot;</span></span>
+<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a>        parent_id<span class="op">:</span> <span class="st">&quot;0&quot;</span><span class="op">.</span>to_string()<span class="op">,</span>  <span class="co">// Toujours &quot;0&quot; pour la racine</span></span>
+<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a>        restricted<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;1&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a>        child_count<span class="op">:</span> <span class="cn">None</span><span class="op">,</span>  <span class="co">// Optionnel</span></span>
+<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a>        searchable<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;1&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a>        title<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>name()<span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a>        class<span class="op">:</span> <span class="st">&quot;object.container&quot;</span><span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a>        artist<span class="op">:</span> <span class="cn">None</span><span class="op">,</span></span>
+<span id="cb4-11"><a href="#cb4-11" aria-hidden="true" tabindex="-1"></a>        album_art<span class="op">:</span> <span class="cn">None</span><span class="op">,</span></span>
+<span id="cb4-12"><a href="#cb4-12" aria-hidden="true" tabindex="-1"></a>        containers<span class="op">:</span> <span class="pp">vec!</span>[]<span class="op">,</span></span>
+<span id="cb4-13"><a href="#cb4-13" aria-hidden="true" tabindex="-1"></a>        items<span class="op">:</span> <span class="pp">vec!</span>[]<span class="op">,</span></span>
+<span id="cb4-14"><a href="#cb4-14" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span>)</span>
+<span id="cb4-15"><a href="#cb4-15" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h4 id="browse">2.2 Browse</h4>
+<p>La méthode <code>browse()</code> est le cœur de la navigation :</p>
+<div class="sourceCode" id="cb5"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> browse(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> object_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>BrowseResult<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">match</span> <span class="kw">self</span><span class="op">.</span>parse_object_id(object_id) <span class="op">{</span></span>
+<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a>        <span class="pp">ObjectIdType::</span>Root <span class="op">=&gt;</span> <span class="op">{</span></span>
+<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Retourner les sous-containers principaux</span></span>
+<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> containers <span class="op">=</span> <span class="pp">vec!</span>[</span>
+<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a>                <span class="kw">self</span><span class="op">.</span>build_albums_container()<span class="op">,</span></span>
+<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a>                <span class="kw">self</span><span class="op">.</span>build_playlists_container()<span class="op">,</span></span>
+<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a>                <span class="kw">self</span><span class="op">.</span>build_favorites_container()<span class="op">,</span></span>
+<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a>            ]<span class="op">;</span></span>
+<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(<span class="pp">BrowseResult::</span>Containers(containers))</span>
+<span id="cb5-11"><a href="#cb5-11" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb5-12"><a href="#cb5-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-13"><a href="#cb5-13" aria-hidden="true" tabindex="-1"></a>        <span class="pp">ObjectIdType::</span>Album <span class="op">{</span> album_id <span class="op">}</span> <span class="op">=&gt;</span> <span class="op">{</span></span>
+<span id="cb5-14"><a href="#cb5-14" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Retourner le container + ses tracks</span></span>
+<span id="cb5-15"><a href="#cb5-15" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> album_container <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>build_album_container(<span class="op">&amp;</span>album_id)<span class="op">;</span></span>
+<span id="cb5-16"><a href="#cb5-16" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> tracks <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>get_album_tracks(<span class="op">&amp;</span>album_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb5-17"><a href="#cb5-17" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(<span class="pp">BrowseResult::</span>Mixed <span class="op">{</span></span>
+<span id="cb5-18"><a href="#cb5-18" aria-hidden="true" tabindex="-1"></a>                containers<span class="op">:</span> <span class="pp">vec!</span>[album_container]<span class="op">,</span></span>
+<span id="cb5-19"><a href="#cb5-19" aria-hidden="true" tabindex="-1"></a>                items<span class="op">:</span> tracks<span class="op">,</span></span>
+<span id="cb5-20"><a href="#cb5-20" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span>)</span>
+<span id="cb5-21"><a href="#cb5-21" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb5-22"><a href="#cb5-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-23"><a href="#cb5-23" aria-hidden="true" tabindex="-1"></a>        <span class="pp">ObjectIdType::</span>Track <span class="op">{</span> track_id <span class="op">}</span> <span class="op">=&gt;</span> <span class="op">{</span></span>
+<span id="cb5-24"><a href="#cb5-24" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Retourner les détails d&#39;un track</span></span>
+<span id="cb5-25"><a href="#cb5-25" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> track <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>get_track_item(<span class="op">&amp;</span>track_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb5-26"><a href="#cb5-26" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(<span class="pp">BrowseResult::</span>Items(<span class="pp">vec!</span>[track]))</span>
+<span id="cb5-27"><a href="#cb5-27" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb5-28"><a href="#cb5-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-29"><a href="#cb5-29" aria-hidden="true" tabindex="-1"></a>        _ <span class="op">=&gt;</span> <span class="cn">Err</span>(<span class="pp">MusicSourceError::</span>ObjectNotFound(</span>
+<span id="cb5-30"><a href="#cb5-30" aria-hidden="true" tabindex="-1"></a>            <span class="pp">format!</span>(<span class="st">&quot;Unknown object: {}&quot;</span><span class="op">,</span> object_id)</span>
+<span id="cb5-31"><a href="#cb5-31" aria-hidden="true" tabindex="-1"></a>        ))</span>
+<span id="cb5-32"><a href="#cb5-32" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb5-33"><a href="#cb5-33" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Schema d’Object ID recommandé :</strong></p>
+<pre><code>&lt;source-id&gt;                              # Racine
+&lt;source-id&gt;:albums                       # Container albums
+&lt;source-id&gt;:album:&lt;album_id&gt;             # Album spécifique
+&lt;source-id&gt;:track:&lt;track_id&gt;             # Track spécifique
+&lt;source-id&gt;:playlist:&lt;playlist_id&gt;       # Playlist spécifique</pre>
+<p><strong>Types de BrowseResult :</strong> -
+<code>Containers(Vec&lt;Container&gt;)</code> : Liste de containers
+(navigation) - <code>Items(Vec&lt;Item&gt;)</code> : Liste de tracks
+(lecture) - <code>Mixed { containers, items }</code> : Les deux (album
+avec tracks)</p>
+<h4 id="résolution-duri">2.3 Résolution d’URI</h4>
+<div class="sourceCode" id="cb7"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> resolve_uri(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> object_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Étape 1 : Vérifier le cache audio</span></span>
+<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(cached_pk) <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>get_cached_audio_pk(object_id)<span class="op">.</span><span class="kw">await</span> <span class="op">{</span></span>
+<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="cn">Ok</span>(<span class="pp">format!</span>(<span class="st">&quot;{}/audio/flac/{}&quot;</span><span class="op">,</span> <span class="kw">self</span><span class="op">.</span>base_url<span class="op">,</span> cached_pk))<span class="op">;</span></span>
+<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Étape 2 : Retourner l&#39;URI originale</span></span>
+<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">match</span> <span class="kw">self</span><span class="op">.</span>parse_object_id(object_id) <span class="op">{</span></span>
+<span id="cb7-9"><a href="#cb7-9" aria-hidden="true" tabindex="-1"></a>        <span class="pp">ObjectIdType::</span>Track <span class="op">{</span> track_id <span class="op">}</span> <span class="op">=&gt;</span> <span class="op">{</span></span>
+<span id="cb7-10"><a href="#cb7-10" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> stream_url <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>get_stream_url(<span class="op">&amp;</span>track_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb7-11"><a href="#cb7-11" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(stream_url)</span>
+<span id="cb7-12"><a href="#cb7-12" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb7-13"><a href="#cb7-13" aria-hidden="true" tabindex="-1"></a>        _ <span class="op">=&gt;</span> <span class="cn">Err</span>(<span class="pp">MusicSourceError::</span>UriResolutionError(</span>
+<span id="cb7-14"><a href="#cb7-14" aria-hidden="true" tabindex="-1"></a>            <span class="pp">format!</span>(<span class="st">&quot;Cannot resolve URI for: {}&quot;</span><span class="op">,</span> object_id)</span>
+<span id="cb7-15"><a href="#cb7-15" aria-hidden="true" tabindex="-1"></a>        ))</span>
+<span id="cb7-16"><a href="#cb7-16" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb7-17"><a href="#cb7-17" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Ordre de résolution :</strong> 1. Cache audio local (si
+disponible) 2. URI originale (API streaming, fichier local, etc.)</p>
+<h3 id="support-fifo-sources-dynamiques">3. Support FIFO (sources
+dynamiques)</h3>
+<p>Si votre source est dynamique (radio, streaming live) :</p>
+<div class="sourceCode" id="cb8"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmoplaylist::</span>PlaylistManager<span class="op">;</span></span>
+<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">std::sync::</span>Arc<span class="op">;</span></span>
+<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">tokio::sync::</span>RwLock<span class="op">;</span></span>
+<span id="cb8-4"><a href="#cb8-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Clone</span><span class="at">)]</span></span>
+<span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> RadioSource <span class="op">{</span></span>
+<span id="cb8-7"><a href="#cb8-7" aria-hidden="true" tabindex="-1"></a>    playlist_id<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb8-8"><a href="#cb8-8" aria-hidden="true" tabindex="-1"></a>    update_counter<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;&gt;,</span></span>
+<span id="cb8-9"><a href="#cb8-9" aria-hidden="true" tabindex="-1"></a>    last_change<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span>SystemTime<span class="op">&gt;&gt;,</span></span>
+<span id="cb8-10"><a href="#cb8-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb8-11"><a href="#cb8-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-12"><a href="#cb8-12" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb8-13"><a href="#cb8-13" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> MusicSource <span class="cf">for</span> RadioSource <span class="op">{</span></span>
+<span id="cb8-14"><a href="#cb8-14" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> supports_fifo(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
+<span id="cb8-15"><a href="#cb8-15" aria-hidden="true" tabindex="-1"></a>        <span class="cn">true</span>  <span class="co">// Cette source utilise une FIFO</span></span>
+<span id="cb8-16"><a href="#cb8-16" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-17"><a href="#cb8-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-18"><a href="#cb8-18" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> append_track(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> track<span class="op">:</span> Item) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb8-19"><a href="#cb8-19" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Récupérer le gestionnaire de playlist</span></span>
+<span id="cb8-20"><a href="#cb8-20" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> manager <span class="op">=</span> PlaylistManager()<span class="op">;</span></span>
+<span id="cb8-21"><a href="#cb8-21" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> writer <span class="op">=</span> manager</span>
+<span id="cb8-22"><a href="#cb8-22" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>get_persistent_write_handle(<span class="kw">self</span><span class="op">.</span>playlist_id<span class="op">.</span>clone())</span>
+<span id="cb8-23"><a href="#cb8-23" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-24"><a href="#cb8-24" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">MusicSourceError::</span>PlaylistError(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb8-25"><a href="#cb8-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-26"><a href="#cb8-26" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Extraire le PK depuis l&#39;URI du track</span></span>
+<span id="cb8-27"><a href="#cb8-27" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> pk <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>extract_pk_from_item(<span class="op">&amp;</span>track)<span class="op">?;</span></span>
+<span id="cb8-28"><a href="#cb8-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-29"><a href="#cb8-29" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Ajouter à la playlist</span></span>
+<span id="cb8-30"><a href="#cb8-30" aria-hidden="true" tabindex="-1"></a>        writer</span>
+<span id="cb8-31"><a href="#cb8-31" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>push_lazy(pk)</span>
+<span id="cb8-32"><a href="#cb8-32" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-33"><a href="#cb8-33" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">MusicSourceError::</span>PlaylistError(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb8-34"><a href="#cb8-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-35"><a href="#cb8-35" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Incrémenter update_id</span></span>
+<span id="cb8-36"><a href="#cb8-36" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>bump_update_counter()<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb8-37"><a href="#cb8-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-38"><a href="#cb8-38" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(())</span>
+<span id="cb8-39"><a href="#cb8-39" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-40"><a href="#cb8-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-41"><a href="#cb8-41" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> remove_oldest(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Option</span><span class="op">&lt;</span>Item<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb8-42"><a href="#cb8-42" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> manager <span class="op">=</span> PlaylistManager()<span class="op">;</span></span>
+<span id="cb8-43"><a href="#cb8-43" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> reader <span class="op">=</span> manager</span>
+<span id="cb8-44"><a href="#cb8-44" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>get_read_handle(<span class="op">&amp;</span><span class="kw">self</span><span class="op">.</span>playlist_id)</span>
+<span id="cb8-45"><a href="#cb8-45" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-46"><a href="#cb8-46" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">MusicSourceError::</span>PlaylistError(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb8-47"><a href="#cb8-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-48"><a href="#cb8-48" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Récupérer le plus ancien</span></span>
+<span id="cb8-49"><a href="#cb8-49" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> items <span class="op">=</span> reader<span class="op">.</span>to_items(<span class="dv">1</span>)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-50"><a href="#cb8-50" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">MusicSourceError::</span>PlaylistError(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb8-51"><a href="#cb8-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-52"><a href="#cb8-52" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(item) <span class="op">=</span> items<span class="op">.</span>first() <span class="op">{</span></span>
+<span id="cb8-53"><a href="#cb8-53" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Adapter l&#39;item au schéma de la source</span></span>
+<span id="cb8-54"><a href="#cb8-54" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> adapted <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>adapt_item_to_schema(item<span class="op">.</span>clone())<span class="op">;</span></span>
+<span id="cb8-55"><a href="#cb8-55" aria-hidden="true" tabindex="-1"></a>            <span class="kw">self</span><span class="op">.</span>bump_update_counter()<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb8-56"><a href="#cb8-56" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(<span class="cn">Some</span>(adapted))</span>
+<span id="cb8-57"><a href="#cb8-57" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb8-58"><a href="#cb8-58" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(<span class="cn">None</span>)</span>
+<span id="cb8-59"><a href="#cb8-59" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb8-60"><a href="#cb8-60" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-61"><a href="#cb8-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-62"><a href="#cb8-62" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> update_id(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">u32</span> <span class="op">{</span></span>
+<span id="cb8-63"><a href="#cb8-63" aria-hidden="true" tabindex="-1"></a>        <span class="op">*</span><span class="kw">self</span><span class="op">.</span>update_counter<span class="op">.</span>read()<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-64"><a href="#cb8-64" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-65"><a href="#cb8-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-66"><a href="#cb8-66" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> last_change(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Option</span><span class="op">&lt;</span>SystemTime<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb8-67"><a href="#cb8-67" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Some</span>(<span class="op">*</span><span class="kw">self</span><span class="op">.</span>last_change<span class="op">.</span>read()<span class="op">.</span><span class="kw">await</span>)</span>
+<span id="cb8-68"><a href="#cb8-68" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-69"><a href="#cb8-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-70"><a href="#cb8-70" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> get_items(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> offset<span class="op">:</span> <span class="dt">usize</span><span class="op">,</span> count<span class="op">:</span> <span class="dt">usize</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span>Item<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb8-71"><a href="#cb8-71" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> manager <span class="op">=</span> PlaylistManager()<span class="op">;</span></span>
+<span id="cb8-72"><a href="#cb8-72" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> reader <span class="op">=</span> manager</span>
+<span id="cb8-73"><a href="#cb8-73" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>get_read_handle(<span class="op">&amp;</span><span class="kw">self</span><span class="op">.</span>playlist_id)</span>
+<span id="cb8-74"><a href="#cb8-74" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-75"><a href="#cb8-75" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">MusicSourceError::</span>PlaylistError(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb8-76"><a href="#cb8-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-77"><a href="#cb8-77" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Récupérer les items</span></span>
+<span id="cb8-78"><a href="#cb8-78" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> items <span class="op">=</span> reader</span>
+<span id="cb8-79"><a href="#cb8-79" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>to_items(count)</span>
+<span id="cb8-80"><a href="#cb8-80" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb8-81"><a href="#cb8-81" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">MusicSourceError::</span>PlaylistError(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb8-82"><a href="#cb8-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-83"><a href="#cb8-83" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Adapter au schéma de la source</span></span>
+<span id="cb8-84"><a href="#cb8-84" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> adapted <span class="op">=</span> items<span class="op">.</span>into_iter()</span>
+<span id="cb8-85"><a href="#cb8-85" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map(<span class="op">|</span>item<span class="op">|</span> <span class="kw">self</span><span class="op">.</span>adapt_item_to_schema(item))</span>
+<span id="cb8-86"><a href="#cb8-86" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>collect()<span class="op">;</span></span>
+<span id="cb8-87"><a href="#cb8-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-88"><a href="#cb8-88" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(adapted)</span>
+<span id="cb8-89"><a href="#cb8-89" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-90"><a href="#cb8-90" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb8-91"><a href="#cb8-91" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-92"><a href="#cb8-92" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> RadioSource <span class="op">{</span></span>
+<span id="cb8-93"><a href="#cb8-93" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> bump_update_counter(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">{</span></span>
+<span id="cb8-94"><a href="#cb8-94" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> <span class="kw">mut</span> counter <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>update_counter<span class="op">.</span>write()<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb8-95"><a href="#cb8-95" aria-hidden="true" tabindex="-1"></a>        <span class="op">*</span>counter <span class="op">=</span> counter<span class="op">.</span>wrapping_add(<span class="dv">1</span>)<span class="op">.</span>max(<span class="dv">1</span>)<span class="op">;</span></span>
+<span id="cb8-96"><a href="#cb8-96" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> <span class="kw">mut</span> last <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>last_change<span class="op">.</span>write()<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb8-97"><a href="#cb8-97" aria-hidden="true" tabindex="-1"></a>        <span class="op">*</span>last <span class="op">=</span> <span class="pp">SystemTime::</span>now()<span class="op">;</span></span>
+<span id="cb8-98"><a href="#cb8-98" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-99"><a href="#cb8-99" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Points clés :</strong> - Utiliser
+<code>pmoplaylist::PlaylistManager</code> singleton - Incrémenter
+<code>update_id</code> à chaque modification - Mettre à jour
+<code>last_change</code> à chaque modification - Adapter les IDs des
+items au schéma de la source</p>
+<h3 id="support-statique-albums-bibliothèques">4. Support statique
+(albums, bibliothèques)</h3>
+<p>Si votre source est statique (catalogue, albums) :</p>
+<div class="sourceCode" id="cb9"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> MusicSource <span class="cf">for</span> CatalogSource <span class="op">{</span></span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> supports_fifo(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
+<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a>        <span class="cn">false</span>  <span class="co">// Pas de FIFO</span></span>
+<span id="cb9-5"><a href="#cb9-5" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb9-6"><a href="#cb9-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-7"><a href="#cb9-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> append_track(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> _track<span class="op">:</span> Item) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb9-8"><a href="#cb9-8" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Err</span>(<span class="pp">MusicSourceError::</span>NotSupported(</span>
+<span id="cb9-9"><a href="#cb9-9" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;This source is read-only&quot;</span><span class="op">.</span>to_string()</span>
+<span id="cb9-10"><a href="#cb9-10" aria-hidden="true" tabindex="-1"></a>        ))</span>
+<span id="cb9-11"><a href="#cb9-11" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb9-12"><a href="#cb9-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-13"><a href="#cb9-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> remove_oldest(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Option</span><span class="op">&lt;</span>Item<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb9-14"><a href="#cb9-14" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(<span class="cn">None</span>)  <span class="co">// Pas de suppression</span></span>
+<span id="cb9-15"><a href="#cb9-15" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb9-16"><a href="#cb9-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-17"><a href="#cb9-17" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> update_id(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">u32</span> <span class="op">{</span></span>
+<span id="cb9-18"><a href="#cb9-18" aria-hidden="true" tabindex="-1"></a>        <span class="dv">0</span>  <span class="co">// Jamais de changement</span></span>
+<span id="cb9-19"><a href="#cb9-19" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb9-20"><a href="#cb9-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-21"><a href="#cb9-21" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> last_change(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Option</span><span class="op">&lt;</span>SystemTime<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb9-22"><a href="#cb9-22" aria-hidden="true" tabindex="-1"></a>        <span class="cn">None</span>  <span class="co">// Pas de suivi des changements</span></span>
+<span id="cb9-23"><a href="#cb9-23" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb9-24"><a href="#cb9-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-25"><a href="#cb9-25" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> get_items(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> offset<span class="op">:</span> <span class="dt">usize</span><span class="op">,</span> count<span class="op">:</span> <span class="dt">usize</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span>Item<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb9-26"><a href="#cb9-26" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Retourner une liste paginée depuis le catalogue</span></span>
+<span id="cb9-27"><a href="#cb9-27" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>get_catalog_items(offset<span class="op">,</span> count)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb9-28"><a href="#cb9-28" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb9-29"><a href="#cb9-29" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h2 id="patterns-dimplémentation">Patterns d’implémentation</h2>
+<h3 id="pattern-1-source-dynamique-avec-fifo-radio-paradise">Pattern 1 :
+Source dynamique avec FIFO (Radio Paradise)</h3>
+<p><strong>Caractéristiques :</strong> - Flux continu de tracks -
+Capacité limitée (50-100 tracks) - Suppression automatique des plus
+anciens - <code>supports_fifo() = true</code></p>
+<p><strong>Structure :</strong></p>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Clone</span><span class="at">)]</span></span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> RadioParadiseSource <span class="op">{</span></span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a>    base_url<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a>    update_counter<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;&gt;,</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a>    last_change<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span>SystemTime<span class="op">&gt;&gt;,</span></span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a>    callback_tokens<span class="op">:</span> Arc<span class="op">&lt;</span><span class="pp">std::sync::</span>Mutex<span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">u64</span><span class="op">&gt;&gt;&gt;,</span></span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a>    container_notifier<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span><span class="kw">dyn</span> <span class="bu">Fn</span>(<span class="op">&amp;</span>[<span class="dt">String</span>]) <span class="op">+</span> <span class="bu">Send</span> <span class="op">+</span> <span class="bu">Sync</span><span class="op">&gt;&gt;,</span></span>
+<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> RadioParadiseSource <span class="op">{</span></span>
+<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Enregistrer des callbacks sur les playlists pour notifier les changements</span></span>
+<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> attach_playlist_callbacks(<span class="kw">self</span><span class="op">:</span> <span class="op">&amp;</span>Arc<span class="op">&lt;</span><span class="dt">Self</span><span class="op">&gt;</span>) <span class="op">{</span></span>
+<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> playlist_ids <span class="op">=</span> <span class="pp">vec!</span>[</span>
+<span id="cb10-14"><a href="#cb10-14" aria-hidden="true" tabindex="-1"></a>            <span class="kw">self</span><span class="op">.</span>live_playlist_id()<span class="op">,</span></span>
+<span id="cb10-15"><a href="#cb10-15" aria-hidden="true" tabindex="-1"></a>            <span class="kw">self</span><span class="op">.</span>history_playlist_id()<span class="op">,</span></span>
+<span id="cb10-16"><a href="#cb10-16" aria-hidden="true" tabindex="-1"></a>        ]<span class="op">;</span></span>
+<span id="cb10-17"><a href="#cb10-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-18"><a href="#cb10-18" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> manager <span class="op">=</span> PlaylistManager()<span class="op">;</span></span>
+<span id="cb10-19"><a href="#cb10-19" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> <span class="kw">mut</span> tokens <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>callback_tokens<span class="op">.</span>lock()<span class="op">.</span>unwrap()<span class="op">;</span></span>
+<span id="cb10-20"><a href="#cb10-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-21"><a href="#cb10-21" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> pid <span class="kw">in</span> playlist_ids <span class="op">{</span></span>
+<span id="cb10-22"><a href="#cb10-22" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> weak <span class="op">=</span> <span class="pp">Arc::</span>downgrade(<span class="kw">self</span>)<span class="op">;</span></span>
+<span id="cb10-23"><a href="#cb10-23" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> pid_clone <span class="op">=</span> pid<span class="op">.</span>clone()<span class="op">;</span></span>
+<span id="cb10-24"><a href="#cb10-24" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> token <span class="op">=</span> manager<span class="op">.</span>register_callback(<span class="kw">move</span> <span class="op">|</span>event<span class="op">|</span> <span class="op">{</span></span>
+<span id="cb10-25"><a href="#cb10-25" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> event<span class="op">.</span>playlist_id <span class="op">==</span> pid_clone <span class="op">{</span></span>
+<span id="cb10-26"><a href="#cb10-26" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(strong) <span class="op">=</span> weak<span class="op">.</span>upgrade() <span class="op">{</span></span>
+<span id="cb10-27"><a href="#cb10-27" aria-hidden="true" tabindex="-1"></a>                        <span class="pp">tokio::</span>spawn(<span class="kw">async</span> <span class="kw">move</span> <span class="op">{</span></span>
+<span id="cb10-28"><a href="#cb10-28" aria-hidden="true" tabindex="-1"></a>                            strong<span class="op">.</span>bump_update_counter()<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb10-29"><a href="#cb10-29" aria-hidden="true" tabindex="-1"></a>                            <span class="co">// Notifier ContentDirectory</span></span>
+<span id="cb10-30"><a href="#cb10-30" aria-hidden="true" tabindex="-1"></a>                            <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(notifier) <span class="op">=</span> strong<span class="op">.</span>container_notifier<span class="op">.</span>as_ref() <span class="op">{</span></span>
+<span id="cb10-31"><a href="#cb10-31" aria-hidden="true" tabindex="-1"></a>                                notifier(<span class="op">&amp;</span>[<span class="pp">format!</span>(<span class="st">&quot;radio-paradise:history&quot;</span>)])<span class="op">;</span></span>
+<span id="cb10-32"><a href="#cb10-32" aria-hidden="true" tabindex="-1"></a>                            <span class="op">}</span></span>
+<span id="cb10-33"><a href="#cb10-33" aria-hidden="true" tabindex="-1"></a>                        <span class="op">}</span>)<span class="op">;</span></span>
+<span id="cb10-34"><a href="#cb10-34" aria-hidden="true" tabindex="-1"></a>                    <span class="op">}</span></span>
+<span id="cb10-35"><a href="#cb10-35" aria-hidden="true" tabindex="-1"></a>                <span class="op">}</span></span>
+<span id="cb10-36"><a href="#cb10-36" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span>)<span class="op">;</span></span>
+<span id="cb10-37"><a href="#cb10-37" aria-hidden="true" tabindex="-1"></a>            tokens<span class="op">.</span>push(token)<span class="op">;</span></span>
+<span id="cb10-38"><a href="#cb10-38" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb10-39"><a href="#cb10-39" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Points clés :</strong> - Callbacks sur
+<code>pmoplaylist</code> pour détecter les changements - Notification du
+ContentDirectory via un notifier injecté - <code>update_counter</code>
+partagé via <code>Arc&lt;RwLock&lt;u32&gt;&gt;</code></p>
+<h3 id="pattern-2-source-catalogue-avec-playlists-lazy-qobuz">Pattern 2
+: Source catalogue avec playlists lazy (Qobuz)</h3>
+<p><strong>Caractéristiques :</strong> - Catalogue vaste (millions de
+tracks) - Playlists créées à la demande - Cache lazy (cover eager, audio
+lazy) - <code>supports_fifo() = false</code></p>
+<p><strong>Structure :</strong></p>
+<div class="sourceCode" id="cb11"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Clone</span><span class="at">)]</span></span>
+<span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> QobuzSource <span class="op">{</span></span>
+<span id="cb11-3"><a href="#cb11-3" aria-hidden="true" tabindex="-1"></a>    inner<span class="op">:</span> Arc<span class="op">&lt;</span>QobuzSourceInner<span class="op">&gt;,</span></span>
+<span id="cb11-4"><a href="#cb11-4" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb11-5"><a href="#cb11-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-6"><a href="#cb11-6" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> QobuzSourceInner <span class="op">{</span></span>
+<span id="cb11-7"><a href="#cb11-7" aria-hidden="true" tabindex="-1"></a>    client<span class="op">:</span> Arc<span class="op">&lt;</span>QobuzClient<span class="op">&gt;,</span></span>
+<span id="cb11-8"><a href="#cb11-8" aria-hidden="true" tabindex="-1"></a>    cache_manager<span class="op">:</span> SourceCacheManager<span class="op">,</span></span>
+<span id="cb11-9"><a href="#cb11-9" aria-hidden="true" tabindex="-1"></a>    base_url<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb11-10"><a href="#cb11-10" aria-hidden="true" tabindex="-1"></a>    update_counter<span class="op">:</span> <span class="pp">tokio::sync::</span>RwLock<span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;,</span></span>
+<span id="cb11-11"><a href="#cb11-11" aria-hidden="true" tabindex="-1"></a>    last_change<span class="op">:</span> <span class="pp">tokio::sync::</span>RwLock<span class="op">&lt;</span>SystemTime<span class="op">&gt;,</span></span>
+<span id="cb11-12"><a href="#cb11-12" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb11-13"><a href="#cb11-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-14"><a href="#cb11-14" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> QobuzSource <span class="op">{</span></span>
+<span id="cb11-15"><a href="#cb11-15" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Ajouter un track avec cache lazy</span></span>
+<span id="cb11-16"><a href="#cb11-16" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">async</span> <span class="kw">fn</span> add_track_lazy(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> track<span class="op">:</span> <span class="op">&amp;</span>Track) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>(<span class="dt">String</span><span class="op">,</span> <span class="dt">String</span>)<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb11-17"><a href="#cb11-17" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> track_id <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;qobuz://track/{}&quot;</span><span class="op">,</span> track<span class="op">.</span>id)<span class="op">;</span></span>
+<span id="cb11-18"><a href="#cb11-18" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> lazy_pk <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;QOBUZ:{}&quot;</span><span class="op">,</span> track<span class="op">.</span>id)<span class="op">;</span></span>
+<span id="cb11-19"><a href="#cb11-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-20"><a href="#cb11-20" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 1. Cache cover EAGERLY (petit, UI en a besoin)</span></span>
+<span id="cb11-21"><a href="#cb11-21" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> cached_cover_pk <span class="op">=</span> <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(<span class="kw">ref</span> image_url) <span class="op">=</span> track<span class="op">.</span>album<span class="op">.</span>as_ref()</span>
+<span id="cb11-22"><a href="#cb11-22" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>and_then(<span class="op">|</span>a<span class="op">|</span> a<span class="op">.</span>image<span class="op">.</span>as_ref()) <span class="op">{</span></span>
+<span id="cb11-23"><a href="#cb11-23" aria-hidden="true" tabindex="-1"></a>            <span class="kw">self</span><span class="op">.</span>inner<span class="op">.</span>cache_manager<span class="op">.</span>cache_cover(image_url)<span class="op">.</span><span class="kw">await</span><span class="op">.</span>ok()</span>
+<span id="cb11-24"><a href="#cb11-24" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb11-25"><a href="#cb11-25" aria-hidden="true" tabindex="-1"></a>            <span class="cn">None</span></span>
+<span id="cb11-26"><a href="#cb11-26" aria-hidden="true" tabindex="-1"></a>        <span class="op">};</span></span>
+<span id="cb11-27"><a href="#cb11-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-28"><a href="#cb11-28" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 2. Préparer metadata</span></span>
+<span id="cb11-29"><a href="#cb11-29" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> metadata <span class="op">=</span> AudioMetadata <span class="op">{</span></span>
+<span id="cb11-30"><a href="#cb11-30" aria-hidden="true" tabindex="-1"></a>            title<span class="op">:</span> <span class="cn">Some</span>(track<span class="op">.</span>title<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb11-31"><a href="#cb11-31" aria-hidden="true" tabindex="-1"></a>            artist<span class="op">:</span> track<span class="op">.</span>performer<span class="op">.</span>as_ref()<span class="op">.</span>map(<span class="op">|</span>p<span class="op">|</span> p<span class="op">.</span>name<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb11-32"><a href="#cb11-32" aria-hidden="true" tabindex="-1"></a>            album<span class="op">:</span> track<span class="op">.</span>album<span class="op">.</span>as_ref()<span class="op">.</span>map(<span class="op">|</span>a<span class="op">|</span> a<span class="op">.</span>title<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb11-33"><a href="#cb11-33" aria-hidden="true" tabindex="-1"></a>            duration_secs<span class="op">:</span> <span class="cn">Some</span>(track<span class="op">.</span>duration <span class="kw">as</span> <span class="dt">u64</span>)<span class="op">,</span></span>
+<span id="cb11-34"><a href="#cb11-34" aria-hidden="true" tabindex="-1"></a>            <span class="co">// ... autres champs</span></span>
+<span id="cb11-35"><a href="#cb11-35" aria-hidden="true" tabindex="-1"></a>        <span class="op">};</span></span>
+<span id="cb11-36"><a href="#cb11-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-37"><a href="#cb11-37" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 3. Cache audio LAZILY (grand, téléchargé à la demande)</span></span>
+<span id="cb11-38"><a href="#cb11-38" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> cached_audio_pk <span class="op">=</span> <span class="kw">self</span></span>
+<span id="cb11-39"><a href="#cb11-39" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>inner</span>
+<span id="cb11-40"><a href="#cb11-40" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>cache_manager</span>
+<span id="cb11-41"><a href="#cb11-41" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>cache_audio_lazy_with_provider(</span>
+<span id="cb11-42"><a href="#cb11-42" aria-hidden="true" tabindex="-1"></a>                <span class="op">&amp;</span>lazy_pk<span class="op">,</span></span>
+<span id="cb11-43"><a href="#cb11-43" aria-hidden="true" tabindex="-1"></a>                <span class="cn">Some</span>(metadata<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb11-44"><a href="#cb11-44" aria-hidden="true" tabindex="-1"></a>                cached_cover_pk<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb11-45"><a href="#cb11-45" aria-hidden="true" tabindex="-1"></a>            )</span>
+<span id="cb11-46"><a href="#cb11-46" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-47"><a href="#cb11-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-48"><a href="#cb11-48" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 4. Stocker metadata</span></span>
+<span id="cb11-49"><a href="#cb11-49" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>inner<span class="op">.</span>cache_manager<span class="op">.</span>update_metadata(</span>
+<span id="cb11-50"><a href="#cb11-50" aria-hidden="true" tabindex="-1"></a>            track_id<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb11-51"><a href="#cb11-51" aria-hidden="true" tabindex="-1"></a>            <span class="pp">pmosource::</span>TrackMetadata <span class="op">{</span></span>
+<span id="cb11-52"><a href="#cb11-52" aria-hidden="true" tabindex="-1"></a>                original_uri<span class="op">:</span> stream_url<span class="op">,</span></span>
+<span id="cb11-53"><a href="#cb11-53" aria-hidden="true" tabindex="-1"></a>                cached_audio_pk<span class="op">:</span> <span class="cn">Some</span>(cached_audio_pk<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb11-54"><a href="#cb11-54" aria-hidden="true" tabindex="-1"></a>                cached_cover_pk<span class="op">,</span></span>
+<span id="cb11-55"><a href="#cb11-55" aria-hidden="true" tabindex="-1"></a>            <span class="op">},</span></span>
+<span id="cb11-56"><a href="#cb11-56" aria-hidden="true" tabindex="-1"></a>        )<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb11-57"><a href="#cb11-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-58"><a href="#cb11-58" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>((track_id<span class="op">,</span> cached_audio_pk))</span>
+<span id="cb11-59"><a href="#cb11-59" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb11-60"><a href="#cb11-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-61"><a href="#cb11-61" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Créer une playlist d&#39;album avec TTL</span></span>
+<span id="cb11-62"><a href="#cb11-62" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> get_or_create_album_playlist_items(</span>
+<span id="cb11-63"><a href="#cb11-63" aria-hidden="true" tabindex="-1"></a>        <span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span></span>
+<span id="cb11-64"><a href="#cb11-64" aria-hidden="true" tabindex="-1"></a>        album_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span><span class="op">,</span></span>
+<span id="cb11-65"><a href="#cb11-65" aria-hidden="true" tabindex="-1"></a>        limit<span class="op">:</span> <span class="dt">usize</span><span class="op">,</span></span>
+<span id="cb11-66"><a href="#cb11-66" aria-hidden="true" tabindex="-1"></a>    ) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span>Item<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb11-67"><a href="#cb11-67" aria-hidden="true" tabindex="-1"></a>        <span class="kw">const</span> ALBUM_PLAYLIST_TTL<span class="op">:</span> Duration <span class="op">=</span> <span class="pp">Duration::</span>from_secs(<span class="dv">7</span> <span class="op">*</span> <span class="dv">24</span> <span class="op">*</span> <span class="dv">3600</span>)<span class="op">;</span></span>
+<span id="cb11-68"><a href="#cb11-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-69"><a href="#cb11-69" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> playlist_id <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;qobuz-album-{}&quot;</span><span class="op">,</span> album_id)<span class="op">;</span></span>
+<span id="cb11-70"><a href="#cb11-70" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> playlist_manager <span class="op">=</span> PlaylistManager()<span class="op">;</span></span>
+<span id="cb11-71"><a href="#cb11-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-72"><a href="#cb11-72" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Vérifier validité (existe ET non expirée ET non vide)</span></span>
+<span id="cb11-73"><a href="#cb11-73" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> is_valid <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>is_album_playlist_valid(<span class="op">&amp;</span>playlist_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-74"><a href="#cb11-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-75"><a href="#cb11-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> is_valid <span class="op">{</span></span>
+<span id="cb11-76"><a href="#cb11-76" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Récupérer depuis playlist existante</span></span>
+<span id="cb11-77"><a href="#cb11-77" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> reader <span class="op">=</span> playlist_manager<span class="op">.</span>get_read_handle(<span class="op">&amp;</span>playlist_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-78"><a href="#cb11-78" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> items <span class="op">=</span> reader<span class="op">.</span>to_items(limit)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-79"><a href="#cb11-79" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="kw">self</span><span class="op">.</span>adapt_playlist_items_to_qobuz(items<span class="op">,</span> album_id)<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb11-80"><a href="#cb11-80" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb11-81"><a href="#cb11-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-82"><a href="#cb11-82" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Créer nouvelle playlist</span></span>
+<span id="cb11-83"><a href="#cb11-83" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> writer <span class="op">=</span> playlist_manager</span>
+<span id="cb11-84"><a href="#cb11-84" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>create_persistent_playlist_with_role(</span>
+<span id="cb11-85"><a href="#cb11-85" aria-hidden="true" tabindex="-1"></a>                playlist_id<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb11-86"><a href="#cb11-86" aria-hidden="true" tabindex="-1"></a>                <span class="pp">pmoplaylist::PlaylistRole::</span>Album<span class="op">,</span></span>
+<span id="cb11-87"><a href="#cb11-87" aria-hidden="true" tabindex="-1"></a>            )</span>
+<span id="cb11-88"><a href="#cb11-88" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-89"><a href="#cb11-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-90"><a href="#cb11-90" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Ajouter tracks avec cache lazy</span></span>
+<span id="cb11-91"><a href="#cb11-91" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_album_to_playlist(<span class="op">&amp;</span>playlist_id<span class="op">,</span> album_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-92"><a href="#cb11-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-93"><a href="#cb11-93" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Récupérer items</span></span>
+<span id="cb11-94"><a href="#cb11-94" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> reader <span class="op">=</span> playlist_manager<span class="op">.</span>get_read_handle(<span class="op">&amp;</span>playlist_id)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-95"><a href="#cb11-95" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> items <span class="op">=</span> reader<span class="op">.</span>to_items(limit)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb11-96"><a href="#cb11-96" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>adapt_playlist_items_to_qobuz(items<span class="op">,</span> album_id)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb11-97"><a href="#cb11-97" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb11-98"><a href="#cb11-98" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Points clés :</strong> - Cache lazy pour l’audio (téléchargé
+à la demande) - Cache eager pour les covers (petit, UI en a besoin) -
+Playlists avec TTL (7 jours) - <code>LazyProvider</code> pour
+télécharger l’audio lors de la lecture</p>
+<h3 id="pattern-3-adaptation-des-ids-entre-playlist-et-source">Pattern 3
+: Adaptation des IDs entre playlist et source</h3>
+<p>Lorsqu’une source utilise <code>pmoplaylist</code>, les items
+retournés ont des IDs génériques. Il faut les adapter au schéma de la
+source :</p>
+<div class="sourceCode" id="cb12"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> adapt_playlist_items_to_source(</span>
+<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a>    <span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span></span>
+<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a>    items<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>Item<span class="op">&gt;,</span></span>
+<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a>    parent_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span><span class="op">,</span></span>
+<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span>Item<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb12-6"><a href="#cb12-6" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> <span class="kw">mut</span> adapted <span class="op">=</span> <span class="dt">Vec</span><span class="pp">::</span>with_capacity(items<span class="op">.</span>len())<span class="op">;</span></span>
+<span id="cb12-7"><a href="#cb12-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-8"><a href="#cb12-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> <span class="kw">mut</span> item <span class="kw">in</span> items <span class="op">{</span></span>
+<span id="cb12-9"><a href="#cb12-9" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Extraire cache_pk depuis l&#39;URL du resource</span></span>
+<span id="cb12-10"><a href="#cb12-10" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> cache_pk <span class="op">=</span> <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(resource) <span class="op">=</span> item<span class="op">.</span>resources<span class="op">.</span>first() <span class="op">{</span></span>
+<span id="cb12-11"><a href="#cb12-11" aria-hidden="true" tabindex="-1"></a>            resource</span>
+<span id="cb12-12"><a href="#cb12-12" aria-hidden="true" tabindex="-1"></a>                <span class="op">.</span>url</span>
+<span id="cb12-13"><a href="#cb12-13" aria-hidden="true" tabindex="-1"></a>                <span class="op">.</span>strip_prefix(<span class="st">&quot;/audio/flac/&quot;</span>)</span>
+<span id="cb12-14"><a href="#cb12-14" aria-hidden="true" tabindex="-1"></a>                <span class="op">.</span>map(<span class="op">|</span>s<span class="op">|</span> s<span class="op">.</span>to_string())</span>
+<span id="cb12-15"><a href="#cb12-15" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb12-16"><a href="#cb12-16" aria-hidden="true" tabindex="-1"></a>            <span class="cn">None</span></span>
+<span id="cb12-17"><a href="#cb12-17" aria-hidden="true" tabindex="-1"></a>        <span class="op">};</span></span>
+<span id="cb12-18"><a href="#cb12-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-19"><a href="#cb12-19" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(pk) <span class="op">=</span> cache_pk <span class="op">{</span></span>
+<span id="cb12-20"><a href="#cb12-20" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Récupérer source_track_id depuis metadata</span></span>
+<span id="cb12-21"><a href="#cb12-21" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Ok</span>(<span class="cn">Some</span>(track_id_value)) <span class="op">=</span> <span class="kw">self</span></span>
+<span id="cb12-22"><a href="#cb12-22" aria-hidden="true" tabindex="-1"></a>                <span class="op">.</span>cache_manager</span>
+<span id="cb12-23"><a href="#cb12-23" aria-hidden="true" tabindex="-1"></a>                <span class="op">.</span>get_audio_metadata(<span class="op">&amp;</span>pk<span class="op">,</span> <span class="st">&quot;source_track_id&quot;</span>)</span>
+<span id="cb12-24"><a href="#cb12-24" aria-hidden="true" tabindex="-1"></a>            <span class="op">{</span></span>
+<span id="cb12-25"><a href="#cb12-25" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(track_id) <span class="op">=</span> track_id_value<span class="op">.</span>as_str() <span class="op">{</span></span>
+<span id="cb12-26"><a href="#cb12-26" aria-hidden="true" tabindex="-1"></a>                    item<span class="op">.</span>id <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;my-source:track:{}&quot;</span><span class="op">,</span> track_id)<span class="op">;</span></span>
+<span id="cb12-27"><a href="#cb12-27" aria-hidden="true" tabindex="-1"></a>                <span class="op">}</span></span>
+<span id="cb12-28"><a href="#cb12-28" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span></span>
+<span id="cb12-29"><a href="#cb12-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-30"><a href="#cb12-30" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Convertir URL relative en absolue</span></span>
+<span id="cb12-31"><a href="#cb12-31" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(resource) <span class="op">=</span> item<span class="op">.</span>resources<span class="op">.</span>first_mut() <span class="op">{</span></span>
+<span id="cb12-32"><a href="#cb12-32" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> resource<span class="op">.</span>url<span class="op">.</span>starts_with(<span class="ch">&#39;/&#39;</span>) <span class="op">{</span></span>
+<span id="cb12-33"><a href="#cb12-33" aria-hidden="true" tabindex="-1"></a>                    resource<span class="op">.</span>url <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;{}{}&quot;</span><span class="op">,</span> <span class="kw">self</span><span class="op">.</span>base_url<span class="op">,</span> resource<span class="op">.</span>url)<span class="op">;</span></span>
+<span id="cb12-34"><a href="#cb12-34" aria-hidden="true" tabindex="-1"></a>                <span class="op">}</span></span>
+<span id="cb12-35"><a href="#cb12-35" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span></span>
+<span id="cb12-36"><a href="#cb12-36" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb12-37"><a href="#cb12-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-38"><a href="#cb12-38" aria-hidden="true" tabindex="-1"></a>        item<span class="op">.</span>parent_id <span class="op">=</span> parent_id<span class="op">.</span>to_string()<span class="op">;</span></span>
+<span id="cb12-39"><a href="#cb12-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-40"><a href="#cb12-40" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Normaliser album art</span></span>
+<span id="cb12-41"><a href="#cb12-41" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">let</span> <span class="cn">Some</span>(art) <span class="op">=</span> item<span class="op">.</span>album_art<span class="op">.</span>as_mut() <span class="op">{</span></span>
+<span id="cb12-42"><a href="#cb12-42" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> art<span class="op">.</span>starts_with(<span class="ch">&#39;/&#39;</span>) <span class="op">{</span></span>
+<span id="cb12-43"><a href="#cb12-43" aria-hidden="true" tabindex="-1"></a>                <span class="op">*</span>art <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;{}{}&quot;</span><span class="op">,</span> <span class="kw">self</span><span class="op">.</span>base_url<span class="op">,</span> art)<span class="op">;</span></span>
+<span id="cb12-44"><a href="#cb12-44" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span></span>
+<span id="cb12-45"><a href="#cb12-45" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb12-46"><a href="#cb12-46" aria-hidden="true" tabindex="-1"></a>            item<span class="op">.</span>album_art <span class="op">=</span> <span class="cn">Some</span>(<span class="kw">self</span><span class="op">.</span>default_cover_url())<span class="op">;</span></span>
+<span id="cb12-47"><a href="#cb12-47" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb12-48"><a href="#cb12-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-49"><a href="#cb12-49" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Ajouter genre par défaut si absent (requis par certains clients)</span></span>
+<span id="cb12-50"><a href="#cb12-50" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> item<span class="op">.</span>genre<span class="op">.</span>is_none() <span class="op">{</span></span>
+<span id="cb12-51"><a href="#cb12-51" aria-hidden="true" tabindex="-1"></a>            item<span class="op">.</span>genre <span class="op">=</span> <span class="cn">Some</span>(<span class="st">&quot;Music&quot;</span><span class="op">.</span>to_string())<span class="op">;</span></span>
+<span id="cb12-52"><a href="#cb12-52" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb12-53"><a href="#cb12-53" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-54"><a href="#cb12-54" aria-hidden="true" tabindex="-1"></a>        adapted<span class="op">.</span>push(item)<span class="op">;</span></span>
+<span id="cb12-55"><a href="#cb12-55" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb12-56"><a href="#cb12-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-57"><a href="#cb12-57" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>(adapted)</span>
+<span id="cb12-58"><a href="#cb12-58" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Points clés :</strong> - Stocker <code>source_track_id</code>
+dans les metadata du cache audio - Reconstituer l’ID correct lors de la
+récupération depuis playlist - Normaliser URLs (relatives → absolues) -
+Ajouter champs requis par certains clients UPnP</p>
+<h2 id="intégration-avec-lécosystème-pmomusic">Intégration avec
+l’écosystème PMOMusic</h2>
+<h3 id="avec-pmoplaylist">Avec pmoplaylist</h3>
+<p>Pour les sources dynamiques et les catalogues :</p>
+<div class="sourceCode" id="cb13"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmoplaylist::</span><span class="op">{</span>PlaylistManager<span class="op">,</span> PlaylistRole<span class="op">};</span></span>
+<span id="cb13-2"><a href="#cb13-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb13-3"><a href="#cb13-3" aria-hidden="true" tabindex="-1"></a><span class="co">// Créer une playlist persistante</span></span>
+<span id="cb13-4"><a href="#cb13-4" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> manager <span class="op">=</span> PlaylistManager()<span class="op">;</span></span>
+<span id="cb13-5"><a href="#cb13-5" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> writer <span class="op">=</span> manager</span>
+<span id="cb13-6"><a href="#cb13-6" aria-hidden="true" tabindex="-1"></a>    <span class="op">.</span>create_persistent_playlist_with_role(</span>
+<span id="cb13-7"><a href="#cb13-7" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;my-source-album-123&quot;</span><span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb13-8"><a href="#cb13-8" aria-hidden="true" tabindex="-1"></a>        <span class="pp">PlaylistRole::</span>Album<span class="op">,</span></span>
+<span id="cb13-9"><a href="#cb13-9" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb13-10"><a href="#cb13-10" aria-hidden="true" tabindex="-1"></a>    <span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb13-11"><a href="#cb13-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb13-12"><a href="#cb13-12" aria-hidden="true" tabindex="-1"></a><span class="co">// Configurer metadata</span></span>
+<span id="cb13-13"><a href="#cb13-13" aria-hidden="true" tabindex="-1"></a>writer<span class="op">.</span>set_title(<span class="st">&quot;Album Title&quot;</span><span class="op">.</span>to_string())<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb13-14"><a href="#cb13-14" aria-hidden="true" tabindex="-1"></a>writer<span class="op">.</span>set_artist(<span class="cn">Some</span>(<span class="st">&quot;Artist Name&quot;</span><span class="op">.</span>to_string()))<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb13-15"><a href="#cb13-15" aria-hidden="true" tabindex="-1"></a>writer<span class="op">.</span>set_cover_pk(<span class="cn">Some</span>(<span class="st">&quot;cover-pk&quot;</span><span class="op">.</span>to_string()))<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb13-16"><a href="#cb13-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb13-17"><a href="#cb13-17" aria-hidden="true" tabindex="-1"></a><span class="co">// Ajouter tracks avec cache lazy</span></span>
+<span id="cb13-18"><a href="#cb13-18" aria-hidden="true" tabindex="-1"></a>writer<span class="op">.</span>push_lazy_batch(<span class="pp">vec!</span>[<span class="st">&quot;pk1&quot;</span><span class="op">,</span> <span class="st">&quot;pk2&quot;</span><span class="op">,</span> <span class="st">&quot;pk3&quot;</span>])<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb13-19"><a href="#cb13-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb13-20"><a href="#cb13-20" aria-hidden="true" tabindex="-1"></a><span class="co">// Activer mode lazy (lookahead 2 tracks)</span></span>
+<span id="cb13-21"><a href="#cb13-21" aria-hidden="true" tabindex="-1"></a>manager<span class="op">.</span>enable_lazy_mode(<span class="st">&quot;my-source-album-123&quot;</span><span class="op">,</span> <span class="dv">2</span>)<span class="op">;</span></span></pre></div>
+<h3 id="avec-pmoaudiocache-et-pmocovers-via-sourcecachemanager">Avec
+pmoaudiocache et pmocovers (via SourceCacheManager)</h3>
+<div class="sourceCode" id="cb14"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmosource::</span>SourceCacheManager<span class="op">;</span></span>
+<span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-3"><a href="#cb14-3" aria-hidden="true" tabindex="-1"></a><span class="co">// Créer le manager centralisé</span></span>
+<span id="cb14-4"><a href="#cb14-4" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> cache_manager <span class="op">=</span> <span class="pp">SourceCacheManager::</span>from_registry(<span class="st">&quot;my-source&quot;</span><span class="op">.</span>to_string())<span class="op">?;</span></span>
+<span id="cb14-5"><a href="#cb14-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-6"><a href="#cb14-6" aria-hidden="true" tabindex="-1"></a><span class="co">// Enregistrer un LazyProvider</span></span>
+<span id="cb14-7"><a href="#cb14-7" aria-hidden="true" tabindex="-1"></a>cache_manager<span class="op">.</span>register_lazy_provider(<span class="pp">Arc::</span>new(<span class="pp">MyLazyProvider::</span>new(client)))<span class="op">;</span></span>
+<span id="cb14-8"><a href="#cb14-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-9"><a href="#cb14-9" aria-hidden="true" tabindex="-1"></a><span class="co">// Cache eager (cover)</span></span>
+<span id="cb14-10"><a href="#cb14-10" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> cover_pk <span class="op">=</span> cache_manager<span class="op">.</span>cache_cover(<span class="st">&quot;https://example.com/cover.jpg&quot;</span>)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb14-11"><a href="#cb14-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-12"><a href="#cb14-12" aria-hidden="true" tabindex="-1"></a><span class="co">// Cache lazy (audio)</span></span>
+<span id="cb14-13"><a href="#cb14-13" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> audio_pk <span class="op">=</span> cache_manager</span>
+<span id="cb14-14"><a href="#cb14-14" aria-hidden="true" tabindex="-1"></a>    <span class="op">.</span>cache_audio_lazy_with_provider(</span>
+<span id="cb14-15"><a href="#cb14-15" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;MY-SOURCE:123&quot;</span><span class="op">,</span>  <span class="co">// Lazy PK</span></span>
+<span id="cb14-16"><a href="#cb14-16" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Some</span>(metadata)<span class="op">,</span></span>
+<span id="cb14-17"><a href="#cb14-17" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Some</span>(cover_pk)<span class="op">,</span></span>
+<span id="cb14-18"><a href="#cb14-18" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb14-19"><a href="#cb14-19" aria-hidden="true" tabindex="-1"></a>    <span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb14-20"><a href="#cb14-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-21"><a href="#cb14-21" aria-hidden="true" tabindex="-1"></a><span class="co">// Récupérer metadata</span></span>
+<span id="cb14-22"><a href="#cb14-22" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> value <span class="op">=</span> cache_manager<span class="op">.</span>get_audio_metadata(<span class="op">&amp;</span>audio_pk<span class="op">,</span> <span class="st">&quot;key&quot;</span>)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span></pre></div>
+<p><strong>LazyProvider personnalisé :</strong></p>
+<div class="sourceCode" id="cb15"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmoaudiocache::</span><span class="op">{</span>LazyProvider<span class="op">,</span> LazyProviderError<span class="op">};</span></span>
+<span id="cb15-2"><a href="#cb15-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-3"><a href="#cb15-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> MyLazyProvider <span class="op">{</span></span>
+<span id="cb15-4"><a href="#cb15-4" aria-hidden="true" tabindex="-1"></a>    client<span class="op">:</span> Arc<span class="op">&lt;</span>MyClient<span class="op">&gt;,</span></span>
+<span id="cb15-5"><a href="#cb15-5" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb15-6"><a href="#cb15-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-7"><a href="#cb15-7" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb15-8"><a href="#cb15-8" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> LazyProvider <span class="cf">for</span> MyLazyProvider <span class="op">{</span></span>
+<span id="cb15-9"><a href="#cb15-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> fetch_audio(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> lazy_pk<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">u8</span><span class="op">&gt;,</span> LazyProviderError<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb15-10"><a href="#cb15-10" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Extraire l&#39;ID depuis le lazy_pk</span></span>
+<span id="cb15-11"><a href="#cb15-11" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> id <span class="op">=</span> lazy_pk</span>
+<span id="cb15-12"><a href="#cb15-12" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>strip_prefix(<span class="st">&quot;MY-SOURCE:&quot;</span>)</span>
+<span id="cb15-13"><a href="#cb15-13" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>ok_or_else(<span class="op">||</span> <span class="pp">LazyProviderError::</span>InvalidKey)<span class="op">?;</span></span>
+<span id="cb15-14"><a href="#cb15-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-15"><a href="#cb15-15" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Récupérer l&#39;URL de streaming</span></span>
+<span id="cb15-16"><a href="#cb15-16" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> stream_url <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>client<span class="op">.</span>get_stream_url(id)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb15-17"><a href="#cb15-17" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">LazyProviderError::</span>FetchFailed(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb15-18"><a href="#cb15-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-19"><a href="#cb15-19" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Télécharger l&#39;audio</span></span>
+<span id="cb15-20"><a href="#cb15-20" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> response <span class="op">=</span> <span class="pp">reqwest::</span>get(<span class="op">&amp;</span>stream_url)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb15-21"><a href="#cb15-21" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">LazyProviderError::</span>FetchFailed(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb15-22"><a href="#cb15-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-23"><a href="#cb15-23" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> bytes <span class="op">=</span> response<span class="op">.</span>bytes()<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb15-24"><a href="#cb15-24" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="pp">LazyProviderError::</span>FetchFailed(e<span class="op">.</span>to_string()))<span class="op">?;</span></span>
+<span id="cb15-25"><a href="#cb15-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-26"><a href="#cb15-26" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(bytes<span class="op">.</span>to_vec())</span>
+<span id="cb15-27"><a href="#cb15-27" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb15-28"><a href="#cb15-28" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="avec-pmodidl">Avec pmodidl</h3>
+<p>Conversion de vos structures en DIDL-Lite :</p>
+<div class="sourceCode" id="cb16"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmodidl::</span><span class="op">{</span>Container<span class="op">,</span> Item<span class="op">,</span> Resource<span class="op">};</span></span>
+<span id="cb16-2"><a href="#cb16-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb16-3"><a href="#cb16-3" aria-hidden="true" tabindex="-1"></a><span class="co">// Container</span></span>
+<span id="cb16-4"><a href="#cb16-4" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">trait</span> ToDIDLContainer <span class="op">{</span></span>
+<span id="cb16-5"><a href="#cb16-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> to_didl_container(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> parent_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Container<span class="op">&gt;;</span></span>
+<span id="cb16-6"><a href="#cb16-6" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb16-7"><a href="#cb16-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb16-8"><a href="#cb16-8" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> ToDIDLContainer <span class="cf">for</span> MyAlbum <span class="op">{</span></span>
+<span id="cb16-9"><a href="#cb16-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> to_didl_container(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> parent_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Container<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb16-10"><a href="#cb16-10" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(Container <span class="op">{</span></span>
+<span id="cb16-11"><a href="#cb16-11" aria-hidden="true" tabindex="-1"></a>            id<span class="op">:</span> <span class="pp">format!</span>(<span class="st">&quot;my-source:album:{}&quot;</span><span class="op">,</span> <span class="kw">self</span><span class="op">.</span>id)<span class="op">,</span></span>
+<span id="cb16-12"><a href="#cb16-12" aria-hidden="true" tabindex="-1"></a>            parent_id<span class="op">:</span> parent_id<span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb16-13"><a href="#cb16-13" aria-hidden="true" tabindex="-1"></a>            restricted<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;1&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-14"><a href="#cb16-14" aria-hidden="true" tabindex="-1"></a>            child_count<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>tracks_count<span class="op">.</span>map(<span class="op">|</span>c<span class="op">|</span> c<span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-15"><a href="#cb16-15" aria-hidden="true" tabindex="-1"></a>            searchable<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;1&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-16"><a href="#cb16-16" aria-hidden="true" tabindex="-1"></a>            title<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>title<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb16-17"><a href="#cb16-17" aria-hidden="true" tabindex="-1"></a>            class<span class="op">:</span> <span class="st">&quot;object.container.album.musicAlbum&quot;</span><span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb16-18"><a href="#cb16-18" aria-hidden="true" tabindex="-1"></a>            artist<span class="op">:</span> <span class="cn">Some</span>(<span class="kw">self</span><span class="op">.</span>artist<span class="op">.</span>name<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb16-19"><a href="#cb16-19" aria-hidden="true" tabindex="-1"></a>            album_art<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>cover_url<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb16-20"><a href="#cb16-20" aria-hidden="true" tabindex="-1"></a>            containers<span class="op">:</span> <span class="pp">vec!</span>[]<span class="op">,</span></span>
+<span id="cb16-21"><a href="#cb16-21" aria-hidden="true" tabindex="-1"></a>            items<span class="op">:</span> <span class="pp">vec!</span>[]<span class="op">,</span></span>
+<span id="cb16-22"><a href="#cb16-22" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span>)</span>
+<span id="cb16-23"><a href="#cb16-23" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb16-24"><a href="#cb16-24" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb16-25"><a href="#cb16-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb16-26"><a href="#cb16-26" aria-hidden="true" tabindex="-1"></a><span class="co">// Item</span></span>
+<span id="cb16-27"><a href="#cb16-27" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">trait</span> ToDIDLItem <span class="op">{</span></span>
+<span id="cb16-28"><a href="#cb16-28" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> to_didl_item(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> parent_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Item<span class="op">&gt;;</span></span>
+<span id="cb16-29"><a href="#cb16-29" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb16-30"><a href="#cb16-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb16-31"><a href="#cb16-31" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> ToDIDLItem <span class="cf">for</span> MyTrack <span class="op">{</span></span>
+<span id="cb16-32"><a href="#cb16-32" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> to_didl_item(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> parent_id<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Item<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb16-33"><a href="#cb16-33" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(Item <span class="op">{</span></span>
+<span id="cb16-34"><a href="#cb16-34" aria-hidden="true" tabindex="-1"></a>            id<span class="op">:</span> <span class="pp">format!</span>(<span class="st">&quot;my-source:track:{}&quot;</span><span class="op">,</span> <span class="kw">self</span><span class="op">.</span>id)<span class="op">,</span></span>
+<span id="cb16-35"><a href="#cb16-35" aria-hidden="true" tabindex="-1"></a>            parent_id<span class="op">:</span> parent_id<span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb16-36"><a href="#cb16-36" aria-hidden="true" tabindex="-1"></a>            restricted<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;1&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-37"><a href="#cb16-37" aria-hidden="true" tabindex="-1"></a>            title<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>title<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb16-38"><a href="#cb16-38" aria-hidden="true" tabindex="-1"></a>            creator<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>artist<span class="op">.</span>as_ref()<span class="op">.</span>map(<span class="op">|</span>a<span class="op">|</span> a<span class="op">.</span>name<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb16-39"><a href="#cb16-39" aria-hidden="true" tabindex="-1"></a>            class<span class="op">:</span> <span class="st">&quot;object.item.audioItem.musicTrack&quot;</span><span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb16-40"><a href="#cb16-40" aria-hidden="true" tabindex="-1"></a>            artist<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>artist<span class="op">.</span>as_ref()<span class="op">.</span>map(<span class="op">|</span>a<span class="op">|</span> a<span class="op">.</span>name<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb16-41"><a href="#cb16-41" aria-hidden="true" tabindex="-1"></a>            album<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>album<span class="op">.</span>as_ref()<span class="op">.</span>map(<span class="op">|</span>a<span class="op">|</span> a<span class="op">.</span>title<span class="op">.</span>clone())<span class="op">,</span></span>
+<span id="cb16-42"><a href="#cb16-42" aria-hidden="true" tabindex="-1"></a>            genre<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;Music&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-43"><a href="#cb16-43" aria-hidden="true" tabindex="-1"></a>            album_art<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>cover_url<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb16-44"><a href="#cb16-44" aria-hidden="true" tabindex="-1"></a>            album_art_pk<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>cover_pk<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb16-45"><a href="#cb16-45" aria-hidden="true" tabindex="-1"></a>            date<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>release_date<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb16-46"><a href="#cb16-46" aria-hidden="true" tabindex="-1"></a>            original_track_number<span class="op">:</span> <span class="cn">Some</span>(<span class="kw">self</span><span class="op">.</span>track_number)<span class="op">,</span></span>
+<span id="cb16-47"><a href="#cb16-47" aria-hidden="true" tabindex="-1"></a>            resources<span class="op">:</span> <span class="pp">vec!</span>[Resource <span class="op">{</span></span>
+<span id="cb16-48"><a href="#cb16-48" aria-hidden="true" tabindex="-1"></a>                protocol_info<span class="op">:</span> <span class="st">&quot;http-get:*:audio/flac:*&quot;</span><span class="op">.</span>to_string()<span class="op">,</span></span>
+<span id="cb16-49"><a href="#cb16-49" aria-hidden="true" tabindex="-1"></a>                bits_per_sample<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>bit_depth<span class="op">.</span>map(<span class="op">|</span>b<span class="op">|</span> b<span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-50"><a href="#cb16-50" aria-hidden="true" tabindex="-1"></a>                sample_frequency<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>sample_rate<span class="op">.</span>map(<span class="op">|</span>s<span class="op">|</span> s<span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-51"><a href="#cb16-51" aria-hidden="true" tabindex="-1"></a>                nr_audio_channels<span class="op">:</span> <span class="cn">Some</span>(<span class="st">&quot;2&quot;</span><span class="op">.</span>to_string())<span class="op">,</span></span>
+<span id="cb16-52"><a href="#cb16-52" aria-hidden="true" tabindex="-1"></a>                duration<span class="op">:</span> <span class="kw">self</span><span class="op">.</span>duration_as_upnp_format()<span class="op">,</span></span>
+<span id="cb16-53"><a href="#cb16-53" aria-hidden="true" tabindex="-1"></a>                url<span class="op">:</span> <span class="pp">format!</span>(<span class="st">&quot;/audio/flac/{}&quot;</span><span class="op">,</span> <span class="kw">self</span><span class="op">.</span>cache_pk)<span class="op">,</span></span>
+<span id="cb16-54"><a href="#cb16-54" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span>]<span class="op">,</span></span>
+<span id="cb16-55"><a href="#cb16-55" aria-hidden="true" tabindex="-1"></a>            descriptions<span class="op">:</span> <span class="pp">vec!</span>[]<span class="op">,</span></span>
+<span id="cb16-56"><a href="#cb16-56" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span>)</span>
+<span id="cb16-57"><a href="#cb16-57" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb16-58"><a href="#cb16-58" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h2 id="checklist-de-mise-en-œuvre">Checklist de mise en œuvre</h2>
+<h3 id="phase-1-structure-de-base">Phase 1 : Structure de base</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Créer le crate
+<code>pmo&lt;votre-source&gt;</code></label></li>
+<li><label><input type="checkbox" />Ajouter les dépendances dans
+<code>Cargo.toml</code></label></li>
+<li><label><input type="checkbox" />Créer le logo WebP 300x300px dans
+<code>assets/</code></label></li>
+<li><label><input type="checkbox" />Définir la structure
+principale</label></li>
+<li><label><input type="checkbox" />Implémenter <code>name()</code>,
+<code>id()</code>, <code>default_image()</code></label></li>
+</ul>
+<h3 id="phase-2-navigation-contentdirectory">Phase 2 : Navigation
+ContentDirectory</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Définir le schéma d’Object
+ID</label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>root_container()</code></label></li>
+<li><label><input type="checkbox" />Implémenter <code>browse()</code>
+pour la racine</label></li>
+<li><label><input type="checkbox" />Implémenter <code>browse()</code>
+pour les sous-containers</label></li>
+<li><label><input type="checkbox" />Implémenter <code>browse()</code>
+pour les items</label></li>
+<li><label><input type="checkbox" />Tester la navigation avec un client
+UPnP</label></li>
+</ul>
+<h3 id="phase-3-résolution-duri">Phase 3 : Résolution d’URI</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Implémenter
+<code>resolve_uri()</code> avec fallback</label></li>
+<li><label><input type="checkbox" />Intégrer avec
+<code>SourceCacheManager</code></label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>LazyProvider</code> si cache lazy</label></li>
+<li><label><input type="checkbox" />Tester la lecture audio</label></li>
+</ul>
+<h3 id="phase-4-support-fifo-si-dynamique">Phase 4 : Support FIFO (si
+dynamique)</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Décider de la stratégie
+FIFO</label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>supports_fifo() = true</code></label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>append_track()</code></label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>remove_oldest()</code></label></li>
+<li><label><input type="checkbox" />Implémenter <code>update_id()</code>
+et <code>last_change()</code></label></li>
+<li><label><input type="checkbox" />Enregistrer callbacks sur
+playlists</label></li>
+<li><label><input type="checkbox" />Tester ajout/suppression de
+tracks</label></li>
+</ul>
+<h3 id="phase-5-support-statique-si-catalogue">Phase 5 : Support
+statique (si catalogue)</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Implémenter
+<code>supports_fifo() = false</code></label></li>
+<li><label><input type="checkbox" />Implémenter <code>get_items()</code>
+avec pagination</label></li>
+<li><label><input type="checkbox" />Implémenter <code>search()</code> si
+applicable</label></li>
+<li><label><input type="checkbox" />Tester browsing du
+catalogue</label></li>
+</ul>
+<h3 id="phase-6-intégration-avancée">Phase 6 : Intégration avancée</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Implémenter <code>get_item()</code>
+pour metadata</label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>capabilities()</code></label></li>
+<li><label><input type="checkbox" />Implémenter
+<code>get_available_formats()</code></label></li>
+<li><label><input type="checkbox" />Ajouter gestion d’erreurs
+robuste</label></li>
+<li><label><input type="checkbox" />Documenter le code</label></li>
+</ul>
+<h3 id="phase-7-tests-et-validation">Phase 7 : Tests et validation</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Écrire tests unitaires</label></li>
+<li><label><input type="checkbox" />Écrire tests
+d’intégration</label></li>
+<li><label><input type="checkbox" />Tester avec différents clients
+UPnP</label></li>
+<li><label><input type="checkbox" />Valider les
+performances</label></li>
+<li><label><input type="checkbox" />Documenter les
+limitations</label></li>
+</ul>
+<h2 id="exemples-de-référence">Exemples de référence</h2>
+<h3 id="radio-paradise-source-dynamique-fifo">Radio Paradise (source
+dynamique FIFO)</h3>
+<p><strong>Fichier :</strong> <code>pmoparadise/src/source.rs</code></p>
+<p><strong>Points d’intérêt :</strong> - Structure avec
+<code>Arc&lt;RwLock&lt;&gt;&gt;</code> pour l’état partagé - Callbacks
+sur playlists pour détecter les changements - Notifier injecté pour
+ContentDirectory - Adaptation des IDs playlist → Radio Paradise -
+Support de 4 canaux avec sous-containers</p>
+<p><strong>Schema d’Object ID :</strong></p>
+<pre><code>radio-paradise                                    # Racine
+radio-paradise:channel:{slug}                     # Canal (main, mellow, rock, eclectic)
+radio-paradise:channel:{slug}:live                # Stream live
+radio-paradise:channel:{slug}:liveplaylist        # Playlist live (queue)
+radio-paradise:channel:{slug}:liveplaylist:track:{pk}  # Track dans queue
+radio-paradise:channel:{slug}:history             # Historique
+radio-paradise:channel:{slug}:history:track:{pk}  # Track dans historique</pre>
+<h3 id="qobuz-source-catalogue-avec-playlists-lazy">Qobuz (source
+catalogue avec playlists lazy)</h3>
+<p><strong>Fichier :</strong> <code>pmoqobuz/src/source.rs</code></p>
+<p><strong>Points d’intérêt :</strong> - <code>SourceCacheManager</code>
+centralisé - Cache lazy pour audio, eager pour covers -
+<code>LazyProvider</code> personnalisé - Playlists d’albums avec TTL (7
+jours) - Adaptation IDs playlist → Qobuz - Navigation hiérarchique
+complexe (Discover, Genres, Favorites)</p>
+<p><strong>Schema d’Object ID :</strong></p>
+<pre><code>qobuz                                    # Racine
+qobuz:discover                           # Discover Catalog
+qobuz:discover:albums:ideal              # Albums (Ideal Discography)
+qobuz:discover:artists                   # Artistes Featured
+qobuz:genres                             # Discover Genres
+qobuz:genre:{id}                         # Genre spécifique
+qobuz:genre:{id}:new-releases            # Nouveautés du genre
+qobuz:favorites                          # My Music
+qobuz:favorites:albums                   # Albums favoris
+qobuz:album:{id}                         # Album spécifique
+qobuz:track:{id}                         # Track spécifique
+qobuz:playlist:{id}                      # Playlist spécifique
+qobuz:artist:{id}                        # Artiste spécifique</pre>
+<h2 id="conseils-dimplémentation">Conseils d’implémentation</h2>
+<h3 id="performance">Performance</h3>
+<ol type="1">
+<li><strong>Cache agressif</strong> : Utilisez
+<code>SourceCacheManager</code> pour tout</li>
+<li><strong>Pagination</strong> : Limitez le nombre d’items retournés
+(max 100)</li>
+<li><strong>Lazy loading</strong> : Ne chargez que ce qui est
+demandé</li>
+<li><strong>Rate limiting</strong> : Respectez les limites API de la
+source</li>
+<li><strong>Arc&lt;&gt;</strong> : Partagez les données coûteuses</li>
+</ol>
+<h3 id="compatibilité-upnp">Compatibilité UPnP</h3>
+<ol type="1">
+<li><strong>Genre obligatoire</strong> : Certains clients (gupnp-av-cp)
+requièrent <code>&lt;upnp:genre&gt;</code></li>
+<li><strong>URLs absolues</strong> : Toujours retourner des URLs
+complètes (pas de chemins relatifs)</li>
+<li><strong>Protocol Info</strong> : Utilisez
+<code>http-get:*:audio/flac:*</code> pour FLAC</li>
+<li><strong>Duration</strong> : Format <code>H:MM:SS</code> (ex:
+<code>0:03:45</code>)</li>
+<li><strong>childCount</strong> : Optionnel mais recommandé pour
+l’UI</li>
+</ol>
+<h3 id="gestion-derreurs">Gestion d’erreurs</h3>
+<ol type="1">
+<li><strong>ObjectNotFound</strong> : ID invalide</li>
+<li><strong>BrowseError</strong> : Erreur générique de navigation</li>
+<li><strong>UriResolutionError</strong> : Impossible de résoudre
+l’URI</li>
+<li><strong>PlaylistError</strong> : Erreur d’interaction avec
+pmoplaylist</li>
+<li><strong>CacheError</strong> : Erreur de cache</li>
+</ol>
+<h3 id="thread-safety">Thread Safety</h3>
+<ol type="1">
+<li><strong>Arc&lt;RwLock&lt;&gt;&gt;</strong> : Pour l’état mutable
+partagé</li>
+<li><strong>tokio::sync::RwLock</strong> : Pour l’async</li>
+<li><strong>Éviter Rc&lt;&gt;</strong> : Pas thread-safe</li>
+<li><strong>Clone</strong> : Implémentez <code>Clone</code> pour
+<code>Arc&lt;&gt;</code></li>
+</ol>
+<h2 id="conclusion">Conclusion</h2>
+<p>L’implémentation d’une nouvelle <code>MusicSource</code> suit ces
+étapes :</p>
+<ol type="1">
+<li><strong>Définir le schéma d’Object ID</strong> : Hiérarchie claire
+et cohérente</li>
+<li><strong>Implémenter la navigation</strong> : <code>browse()</code>
+pour tous les niveaux</li>
+<li><strong>Résoudre les URIs</strong> : Cache local d’abord, puis
+original</li>
+<li><strong>Gérer le cache</strong> : <code>SourceCacheManager</code> +
+<code>LazyProvider</code></li>
+<li><strong>Adapter les IDs</strong> : Playlist → Schema de la
+source</li>
+<li><strong>Notifier les changements</strong> : <code>update_id</code> +
+callbacks</li>
+</ol>
+<p>Les exemples Radio Paradise et Qobuz couvrent les deux patterns
+principaux : - <strong>Dynamique FIFO</strong> : Radio Paradise -
+<strong>Catalogue lazy</strong> : Qobuz</p>
+<p>En suivant ces patterns, vous obtiendrez une source musicale
+performante, compatible UPnP, et bien intégrée dans l’écosystème
+PMOMusic.</p>
+</article>
+</body>
+</html>

Blackboard_HTML/Architecture_pmoserver_ext.html

@@ -0,0 +1,929 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>pmoserver_ext</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1 id="pattern-dextension-pmoserver-pmoserver_ext">Pattern d’extension
+PMOServer (<code>pmoserver_ext</code>)</h1>
+<h2 id="vue-densemble">Vue d’ensemble</h2>
+<p>Le pattern <code>pmoserver_ext</code> permet d’étendre les
+fonctionnalités du serveur HTTP <code>pmoserver</code> de manière
+modulaire et découplée. Chaque crate spécialisée peut ajouter ses
+propres routes HTTP sans que <code>pmoserver</code> ne dépende de ces
+crates.</p>
+<p><strong>Principe</strong> : Définir un trait d’extension que
+<code>pmoserver::Server</code> implémente via une feature Cargo.</p>
+<h2 id="anatomie-dune-extension">Anatomie d’une extension</h2>
+<h3 id="structure-du-module">1. Structure du module</h3>
+<p>Créer un module <code>pmoserver_ext.rs</code> dans la crate :</p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="co">// pmoXXX/src/pmoserver_ext.rs</span></span>
+<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="kw">crate</span><span class="pp">::</span><span class="op">{</span><span class="co">/* types internes de la crate */</span><span class="op">};</span></span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">async_trait::</span>async_trait<span class="op">;</span></span>
+<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">axum::</span><span class="op">{</span>Router<span class="op">,</span> <span class="pp">routing::</span>get<span class="op">,</span> Json<span class="op">,</span> <span class="pp">extract::</span><span class="op">{</span>State<span class="op">,</span> <span class="dt">Path</span><span class="op">}};</span></span>
+<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">std::sync::</span>Arc<span class="op">;</span></span></pre></div>
+<p>Déclarer le module dans <code>lib.rs</code> :</p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="co">// pmoXXX/src/lib.rs</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">mod</span> pmoserver_ext<span class="op">;</span></span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">use</span> <span class="pp">pmoserver_ext::</span>XXXExt<span class="op">;</span></span></pre></div>
+<p>Ajouter la feature dans <code>Cargo.toml</code> :</p>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode toml"><code class="sourceCode toml"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">[features]</span></span>
+<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="dt">pmoserver</span> <span class="op">=</span> <span class="op">[</span><span class="st">&quot;dep:axum&quot;</span><span class="op">,</span> <span class="st">&quot;dep:async-trait&quot;</span><span class="op">]</span></span>
+<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a><span class="kw">[dependencies]</span></span>
+<span id="cb3-5"><a href="#cb3-5" aria-hidden="true" tabindex="-1"></a><span class="dt">axum</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">version</span><span class="op"> =</span> <span class="st">&quot;0.8&quot;</span><span class="op">, </span><span class="dt">optional</span><span class="op"> =</span> <span class="cn">true</span><span class="op"> }</span></span>
+<span id="cb3-6"><a href="#cb3-6" aria-hidden="true" tabindex="-1"></a><span class="dt">async-trait</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">version</span><span class="op"> =</span> <span class="st">&quot;0.1&quot;</span><span class="op">, </span><span class="dt">optional</span><span class="op"> =</span> <span class="cn">true</span><span class="op"> }</span></span>
+<span id="cb3-7"><a href="#cb3-7" aria-hidden="true" tabindex="-1"></a><span class="dt">pmoserver</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">path</span><span class="op"> =</span> <span class="st">&quot;../pmoserver&quot;</span><span class="op"> }</span></span></pre></div>
+<h3 id="définir-le-trait-dextension">2. Définir le trait
+d’extension</h3>
+<p><strong>Convention de nommage</strong> : <code>{Domaine}Ext</code>
+avec méthodes préfixées <code>init_*</code></p>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="co">/// Trait pour étendre pmoserver avec les fonctionnalités XXX</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">trait</span> XXXExt <span class="op">{</span></span>
+<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Initialise l&#39;extension XXX et enregistre les routes HTTP</span></span>
+<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a>    <span class="co">///</span></span>
+<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// # Arguments</span></span>
+<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// * `param1` - Description du paramètre</span></span>
+<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a>    <span class="co">///</span></span>
+<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// # Returns</span></span>
+<span id="cb4-11"><a href="#cb4-11" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Instance partagée de la ressource créée</span></span>
+<span id="cb4-12"><a href="#cb4-12" aria-hidden="true" tabindex="-1"></a>    <span class="co">///</span></span>
+<span id="cb4-13"><a href="#cb4-13" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// # Exemple</span></span>
+<span id="cb4-14"><a href="#cb4-14" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// ```ignore</span></span>
+<span id="cb4-15"><a href="#cb4-15" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// use pmoserver::ServerBuilder;</span></span>
+<span id="cb4-16"><a href="#cb4-16" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// use pmoXXX::XXXExt;</span></span>
+<span id="cb4-17"><a href="#cb4-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">///</span></span>
+<span id="cb4-18"><a href="#cb4-18" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// let mut server = ServerBuilder::new(...).build();</span></span>
+<span id="cb4-19"><a href="#cb4-19" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// let resource = server.init_xxx(param1).await?;</span></span>
+<span id="cb4-20"><a href="#cb4-20" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// ```</span></span>
+<span id="cb4-21"><a href="#cb4-21" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_xxx(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span><span class="op">,</span> param1<span class="op">:</span> <span class="dt">String</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>Resource<span class="op">&gt;&gt;;</span></span>
+<span id="cb4-22"><a href="#cb4-22" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="implémenter-le-trait">3. Implémenter le trait</h3>
+<p>Implémenter le trait pour <code>pmoserver::Server</code> :</p>
+<div class="sourceCode" id="cb5"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> XXXExt <span class="cf">for</span> <span class="pp">pmoserver::</span>Server <span class="op">{</span></span>
+<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_xxx(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span><span class="op">,</span> param1<span class="op">:</span> <span class="dt">String</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>Resource<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 1. Créer la ressource interne</span></span>
+<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> resource <span class="op">=</span> <span class="pp">Arc::</span>new(<span class="pp">Resource::</span>new(param1)<span class="op">?</span>)<span class="op">;</span></span>
+<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 2. Créer l&#39;état partagé pour les handlers</span></span>
+<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> state <span class="op">=</span> <span class="pp">XxxState::</span>new(resource<span class="op">.</span>clone())<span class="op">;</span></span>
+<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb5-11"><a href="#cb5-11" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 3. Créer le router avec les routes</span></span>
+<span id="cb5-12"><a href="#cb5-12" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> router <span class="op">=</span> create_xxx_router(state)<span class="op">;</span></span>
+<span id="cb5-13"><a href="#cb5-13" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb5-14"><a href="#cb5-14" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 4. Enregistrer le router sur le serveur</span></span>
+<span id="cb5-15"><a href="#cb5-15" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_router(<span class="st">&quot;/api/xxx&quot;</span><span class="op">,</span> router)<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb5-16"><a href="#cb5-16" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb5-17"><a href="#cb5-17" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 5. Retourner la ressource pour usage ultérieur</span></span>
+<span id="cb5-18"><a href="#cb5-18" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(resource)</span>
+<span id="cb5-19"><a href="#cb5-19" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb5-20"><a href="#cb5-20" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="état-partagé-state">4. État partagé (State)</h3>
+<p>Créer une structure d’état cloneable pour les handlers :</p>
+<div class="sourceCode" id="cb6"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="co">/// État partagé pour les handlers XXX</span></span>
+<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Clone</span><span class="at">)]</span></span>
+<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> XxxState <span class="op">{</span></span>
+<span id="cb6-4"><a href="#cb6-4" aria-hidden="true" tabindex="-1"></a>    resource<span class="op">:</span> Arc<span class="op">&lt;</span>Resource<span class="op">&gt;,</span></span>
+<span id="cb6-5"><a href="#cb6-5" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb6-6"><a href="#cb6-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-7"><a href="#cb6-7" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> XxxState <span class="op">{</span></span>
+<span id="cb6-8"><a href="#cb6-8" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> new(resource<span class="op">:</span> Arc<span class="op">&lt;</span>Resource<span class="op">&gt;</span>) <span class="op">-&gt;</span> <span class="dt">Self</span> <span class="op">{</span></span>
+<span id="cb6-9"><a href="#cb6-9" aria-hidden="true" tabindex="-1"></a>        <span class="dt">Self</span> <span class="op">{</span> resource <span class="op">}</span></span>
+<span id="cb6-10"><a href="#cb6-10" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb6-11"><a href="#cb6-11" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="créer-le-router">5. Créer le router</h3>
+<p>Définir les routes et handlers :</p>
+<div class="sourceCode" id="cb7"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="co">/// Crée le router pour l&#39;API XXX</span></span>
+<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a><span class="kw">fn</span> create_xxx_router(state<span class="op">:</span> XxxState) <span class="op">-&gt;</span> Router <span class="op">{</span></span>
+<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a>    <span class="pp">Router::</span>new()</span>
+<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>route(<span class="st">&quot;/items&quot;</span><span class="op">,</span> get(list_items)<span class="op">.</span>post(create_item))</span>
+<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>route(<span class="st">&quot;/items/{id}&quot;</span><span class="op">,</span> get(get_item)<span class="op">.</span>delete(delete_item))</span>
+<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>with_state(state)</span>
+<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-9"><a href="#cb7-9" aria-hidden="true" tabindex="-1"></a><span class="co">// Handlers</span></span>
+<span id="cb7-10"><a href="#cb7-10" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> list_items(</span>
+<span id="cb7-11"><a href="#cb7-11" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;</span></span>
+<span id="cb7-12"><a href="#cb7-12" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> Json<span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span>ItemSummary<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb7-13"><a href="#cb7-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> items <span class="op">=</span> state<span class="op">.</span>resource<span class="op">.</span>list_items()<span class="op">;</span></span>
+<span id="cb7-14"><a href="#cb7-14" aria-hidden="true" tabindex="-1"></a>    Json(items)</span>
+<span id="cb7-15"><a href="#cb7-15" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb7-16"><a href="#cb7-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-17"><a href="#cb7-17" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> get_item(</span>
+<span id="cb7-18"><a href="#cb7-18" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;,</span></span>
+<span id="cb7-19"><a href="#cb7-19" aria-hidden="true" tabindex="-1"></a>    <span class="dt">Path</span>(id)<span class="op">:</span> <span class="dt">Path</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb7-20"><a href="#cb7-20" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Json<span class="op">&lt;</span>Item<span class="op">&gt;,</span> StatusCode<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb7-21"><a href="#cb7-21" aria-hidden="true" tabindex="-1"></a>    state<span class="op">.</span>resource<span class="op">.</span>get_item(<span class="op">&amp;</span>id)</span>
+<span id="cb7-22"><a href="#cb7-22" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>ok_or(<span class="pp">StatusCode::</span>NOT_FOUND)</span>
+<span id="cb7-23"><a href="#cb7-23" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map(Json)</span>
+<span id="cb7-24"><a href="#cb7-24" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h2 id="méthodes-disponibles-du-serveur">Méthodes disponibles du
+serveur</h2>
+<p><code>pmoserver::Server</code> expose ces méthodes pour enregistrer
+des routes :</p>
+<table>
+<colgroup>
+<col style="width: 56%" />
+<col style="width: 43%" />
+</colgroup>
+<thead>
+<tr>
+<th>Méthode</th>
+<th>Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>add_handler(path, handler)</code></td>
+<td>Ajoute un handler simple sans état</td>
+</tr>
+<tr>
+<td><code>add_handler_with_state(path, handler, state)</code></td>
+<td>Ajoute un handler avec état partagé</td>
+</tr>
+<tr>
+<td><code>add_router(path, router)</code></td>
+<td>Monte un sous-router Axum</td>
+</tr>
+<tr>
+<td><code>add_openapi(router, doc, tag)</code></td>
+<td>Enregistre une API avec documentation OpenAPI</td>
+</tr>
+<tr>
+<td><code>add_spa::&lt;W&gt;(path)</code></td>
+<td>Sert une Single Page Application (RustEmbed)</td>
+</tr>
+<tr>
+<td><code>base_url()</code></td>
+<td>Récupère l’URL de base du serveur</td>
+</tr>
+</tbody>
+</table>
+<h2 id="documentation-openapi-avec-utoipa">Documentation OpenAPI avec
+utoipa</h2>
+<p>La documentation OpenAPI est essentielle pour une extension
+<code>pmoserver</code>. Elle génère automatiquement une interface
+Swagger UI et documente les endpoints de l’API.</p>
+<h3 id="configuration-de-base">Configuration de base</h3>
+<p>Ajouter <code>utoipa</code> dans <code>Cargo.toml</code> :</p>
+<div class="sourceCode" id="cb8"><pre
+class="sourceCode toml"><code class="sourceCode toml"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">[dependencies]</span></span>
+<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a><span class="dt">utoipa</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">version</span><span class="op"> =</span> <span class="st">&quot;5&quot;</span><span class="op">, </span><span class="dt">features</span><span class="op"> =</span> <span class="op">[</span><span class="st">&quot;axum_extras&quot;</span><span class="op">] }</span></span>
+<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="dt">serde</span> <span class="op">=</span> <span class="op">{ </span><span class="dt">version</span><span class="op"> =</span> <span class="st">&quot;1&quot;</span><span class="op">, </span><span class="dt">features</span><span class="op"> =</span> <span class="op">[</span><span class="st">&quot;derive&quot;</span><span class="op">] }</span></span></pre></div>
+<h3 id="définir-les-schémas-de-données">1. Définir les schémas de
+données</h3>
+<p>Annoter les structures de réponse/requête avec
+<code>#[derive(ToSchema)]</code> :</p>
+<div class="sourceCode" id="cb9"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">serde::</span><span class="op">{</span>Serialize<span class="op">,</span> Deserialize<span class="op">};</span></span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">utoipa::</span>ToSchema<span class="op">;</span></span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a><span class="co">/// Information sur un item</span></span>
+<span id="cb9-5"><a href="#cb9-5" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> Deserialize<span class="op">,</span> ToSchema<span class="at">)]</span></span>
+<span id="cb9-6"><a href="#cb9-6" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ItemInfo <span class="op">{</span></span>
+<span id="cb9-7"><a href="#cb9-7" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// ID unique de l&#39;item</span></span>
+<span id="cb9-8"><a href="#cb9-8" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="st">&quot;item-123&quot;</span><span class="at">)]</span></span>
+<span id="cb9-9"><a href="#cb9-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> id<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb9-10"><a href="#cb9-10" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb9-11"><a href="#cb9-11" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Nom de l&#39;item</span></span>
+<span id="cb9-12"><a href="#cb9-12" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="st">&quot;Mon Item&quot;</span><span class="at">)]</span></span>
+<span id="cb9-13"><a href="#cb9-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> name<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb9-14"><a href="#cb9-14" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb9-15"><a href="#cb9-15" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Description optionnelle</span></span>
+<span id="cb9-16"><a href="#cb9-16" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="st">&quot;Une description détaillée&quot;</span><span class="at">)]</span></span>
+<span id="cb9-17"><a href="#cb9-17" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> description<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb9-18"><a href="#cb9-18" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb9-19"><a href="#cb9-19" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Timestamp de création (millisecondes)</span></span>
+<span id="cb9-20"><a href="#cb9-20" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="dv">1234567890</span><span class="at">)]</span></span>
+<span id="cb9-21"><a href="#cb9-21" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> created_at<span class="op">:</span> <span class="dt">u64</span><span class="op">,</span></span>
+<span id="cb9-22"><a href="#cb9-22" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb9-23"><a href="#cb9-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-24"><a href="#cb9-24" aria-hidden="true" tabindex="-1"></a><span class="co">/// Liste d&#39;items</span></span>
+<span id="cb9-25"><a href="#cb9-25" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> ToSchema<span class="at">)]</span></span>
+<span id="cb9-26"><a href="#cb9-26" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ItemList <span class="op">{</span></span>
+<span id="cb9-27"><a href="#cb9-27" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Nombre total d&#39;items</span></span>
+<span id="cb9-28"><a href="#cb9-28" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> total<span class="op">:</span> <span class="dt">usize</span><span class="op">,</span></span>
+<span id="cb9-29"><a href="#cb9-29" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb9-30"><a href="#cb9-30" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Items de la page courante</span></span>
+<span id="cb9-31"><a href="#cb9-31" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> items<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>ItemInfo<span class="op">&gt;,</span></span>
+<span id="cb9-32"><a href="#cb9-32" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb9-33"><a href="#cb9-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-34"><a href="#cb9-34" aria-hidden="true" tabindex="-1"></a><span class="co">/// Requête de création d&#39;item</span></span>
+<span id="cb9-35"><a href="#cb9-35" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Deserialize<span class="op">,</span> ToSchema<span class="at">)]</span></span>
+<span id="cb9-36"><a href="#cb9-36" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> CreateItemRequest <span class="op">{</span></span>
+<span id="cb9-37"><a href="#cb9-37" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Nom de l&#39;item à créer</span></span>
+<span id="cb9-38"><a href="#cb9-38" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="st">&quot;Nouvel Item&quot;</span><span class="at">)]</span></span>
+<span id="cb9-39"><a href="#cb9-39" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> name<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb9-40"><a href="#cb9-40" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb9-41"><a href="#cb9-41" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Description optionnelle</span></span>
+<span id="cb9-42"><a href="#cb9-42" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> description<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb9-43"><a href="#cb9-43" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb9-44"><a href="#cb9-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-45"><a href="#cb9-45" aria-hidden="true" tabindex="-1"></a><span class="co">/// Réponse d&#39;erreur standard</span></span>
+<span id="cb9-46"><a href="#cb9-46" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> ToSchema<span class="at">)]</span></span>
+<span id="cb9-47"><a href="#cb9-47" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ErrorResponse <span class="op">{</span></span>
+<span id="cb9-48"><a href="#cb9-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Message d&#39;erreur</span></span>
+<span id="cb9-49"><a href="#cb9-49" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="st">&quot;Item not found&quot;</span><span class="at">)]</span></span>
+<span id="cb9-50"><a href="#cb9-50" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> error<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb9-51"><a href="#cb9-51" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Points clés</strong> : -
+<code>#[schema(example = "...")]</code> : Fournit des exemples pour la
+doc Swagger - Documenter chaque champ avec <code>///</code> pour
+apparaître dans l’API - Utiliser <code>Option&lt;T&gt;</code> pour les
+champs optionnels</p>
+<h3 id="annoter-les-handlers">2. Annoter les handlers</h3>
+<p>Utiliser <code>#[utoipa::path(...)]</code> pour documenter chaque
+endpoint :</p>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="co">/// GET /items - Liste tous les items</span></span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span><span class="pp">utoipa::</span>path<span class="at">(</span></span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a>    get<span class="op">,</span></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a>    path <span class="op">=</span> <span class="st">&quot;/items&quot;</span><span class="op">,</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a>    params<span class="at">(</span></span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span><span class="st">&quot;limit&quot;</span> <span class="op">=</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;,</span> Query<span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Nombre max d&#39;items à retourner&quot;</span><span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span><span class="st">&quot;offset&quot;</span> <span class="op">=</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;,</span> Query<span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Offset pour la pagination&quot;</span><span class="at">)</span></span>
+<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a>    responses<span class="at">(</span></span>
+<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">200</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Liste des items&quot;</span><span class="op">,</span> body <span class="op">=</span> ItemList<span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">500</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Erreur serveur&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span></span>
+<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a>    tag <span class="op">=</span> <span class="st">&quot;items&quot;</span></span>
+<span id="cb10-14"><a href="#cb10-14" aria-hidden="true" tabindex="-1"></a><span class="at">)]</span></span>
+<span id="cb10-15"><a href="#cb10-15" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> list_items(</span>
+<span id="cb10-16"><a href="#cb10-16" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;,</span></span>
+<span id="cb10-17"><a href="#cb10-17" aria-hidden="true" tabindex="-1"></a>    Query(params)<span class="op">:</span> Query<span class="op">&lt;</span>ListParams<span class="op">&gt;,</span></span>
+<span id="cb10-18"><a href="#cb10-18" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Json<span class="op">&lt;</span>ItemList<span class="op">&gt;,</span> (StatusCode<span class="op">,</span> Json<span class="op">&lt;</span>ErrorResponse<span class="op">&gt;</span>)<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb10-19"><a href="#cb10-19" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> items <span class="op">=</span> state<span class="op">.</span>resource<span class="op">.</span>list_items(params<span class="op">.</span>limit<span class="op">,</span> params<span class="op">.</span>offset)</span>
+<span id="cb10-20"><a href="#cb10-20" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> (</span>
+<span id="cb10-21"><a href="#cb10-21" aria-hidden="true" tabindex="-1"></a>            <span class="pp">StatusCode::</span>INTERNAL_SERVER_ERROR<span class="op">,</span></span>
+<span id="cb10-22"><a href="#cb10-22" aria-hidden="true" tabindex="-1"></a>            Json(ErrorResponse <span class="op">{</span> error<span class="op">:</span> e<span class="op">.</span>to_string() <span class="op">}</span>)</span>
+<span id="cb10-23"><a href="#cb10-23" aria-hidden="true" tabindex="-1"></a>        ))<span class="op">?;</span></span>
+<span id="cb10-24"><a href="#cb10-24" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb10-25"><a href="#cb10-25" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>(Json(ItemList <span class="op">{</span></span>
+<span id="cb10-26"><a href="#cb10-26" aria-hidden="true" tabindex="-1"></a>        total<span class="op">:</span> items<span class="op">.</span>len()<span class="op">,</span></span>
+<span id="cb10-27"><a href="#cb10-27" aria-hidden="true" tabindex="-1"></a>        items<span class="op">,</span></span>
+<span id="cb10-28"><a href="#cb10-28" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span>))</span>
+<span id="cb10-29"><a href="#cb10-29" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb10-30"><a href="#cb10-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-31"><a href="#cb10-31" aria-hidden="true" tabindex="-1"></a><span class="co">/// GET /items/{id} - Récupère un item spécifique</span></span>
+<span id="cb10-32"><a href="#cb10-32" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span><span class="pp">utoipa::</span>path<span class="at">(</span></span>
+<span id="cb10-33"><a href="#cb10-33" aria-hidden="true" tabindex="-1"></a>    get<span class="op">,</span></span>
+<span id="cb10-34"><a href="#cb10-34" aria-hidden="true" tabindex="-1"></a>    path <span class="op">=</span> <span class="st">&quot;/items/{id}&quot;</span><span class="op">,</span></span>
+<span id="cb10-35"><a href="#cb10-35" aria-hidden="true" tabindex="-1"></a>    params<span class="at">(</span></span>
+<span id="cb10-36"><a href="#cb10-36" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span><span class="st">&quot;id&quot;</span> <span class="op">=</span> <span class="dt">String</span><span class="op">,</span> <span class="dt">Path</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;ID unique de l&#39;item&quot;</span><span class="at">)</span></span>
+<span id="cb10-37"><a href="#cb10-37" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-38"><a href="#cb10-38" aria-hidden="true" tabindex="-1"></a>    responses<span class="at">(</span></span>
+<span id="cb10-39"><a href="#cb10-39" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">200</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Item trouvé&quot;</span><span class="op">,</span> body <span class="op">=</span> ItemInfo<span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">404</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Item non trouvé&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-41"><a href="#cb10-41" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">500</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Erreur serveur&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span></span>
+<span id="cb10-42"><a href="#cb10-42" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-43"><a href="#cb10-43" aria-hidden="true" tabindex="-1"></a>    tag <span class="op">=</span> <span class="st">&quot;items&quot;</span></span>
+<span id="cb10-44"><a href="#cb10-44" aria-hidden="true" tabindex="-1"></a><span class="at">)]</span></span>
+<span id="cb10-45"><a href="#cb10-45" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> get_item(</span>
+<span id="cb10-46"><a href="#cb10-46" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;,</span></span>
+<span id="cb10-47"><a href="#cb10-47" aria-hidden="true" tabindex="-1"></a>    <span class="dt">Path</span>(id)<span class="op">:</span> <span class="dt">Path</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb10-48"><a href="#cb10-48" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Json<span class="op">&lt;</span>ItemInfo<span class="op">&gt;,</span> (StatusCode<span class="op">,</span> Json<span class="op">&lt;</span>ErrorResponse<span class="op">&gt;</span>)<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb10-49"><a href="#cb10-49" aria-hidden="true" tabindex="-1"></a>    state<span class="op">.</span>resource<span class="op">.</span>get_item(<span class="op">&amp;</span>id)</span>
+<span id="cb10-50"><a href="#cb10-50" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>ok_or_else(<span class="op">||</span> (</span>
+<span id="cb10-51"><a href="#cb10-51" aria-hidden="true" tabindex="-1"></a>            <span class="pp">StatusCode::</span>NOT_FOUND<span class="op">,</span></span>
+<span id="cb10-52"><a href="#cb10-52" aria-hidden="true" tabindex="-1"></a>            Json(ErrorResponse <span class="op">{</span></span>
+<span id="cb10-53"><a href="#cb10-53" aria-hidden="true" tabindex="-1"></a>                error<span class="op">:</span> <span class="pp">format!</span>(<span class="st">&quot;Item {} not found&quot;</span><span class="op">,</span> id)</span>
+<span id="cb10-54"><a href="#cb10-54" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span>)</span>
+<span id="cb10-55"><a href="#cb10-55" aria-hidden="true" tabindex="-1"></a>        ))</span>
+<span id="cb10-56"><a href="#cb10-56" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map(Json)</span>
+<span id="cb10-57"><a href="#cb10-57" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb10-58"><a href="#cb10-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-59"><a href="#cb10-59" aria-hidden="true" tabindex="-1"></a><span class="co">/// POST /items - Crée un nouvel item</span></span>
+<span id="cb10-60"><a href="#cb10-60" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span><span class="pp">utoipa::</span>path<span class="at">(</span></span>
+<span id="cb10-61"><a href="#cb10-61" aria-hidden="true" tabindex="-1"></a>    post<span class="op">,</span></span>
+<span id="cb10-62"><a href="#cb10-62" aria-hidden="true" tabindex="-1"></a>    path <span class="op">=</span> <span class="st">&quot;/items&quot;</span><span class="op">,</span></span>
+<span id="cb10-63"><a href="#cb10-63" aria-hidden="true" tabindex="-1"></a>    request_body <span class="op">=</span> CreateItemRequest<span class="op">,</span></span>
+<span id="cb10-64"><a href="#cb10-64" aria-hidden="true" tabindex="-1"></a>    responses<span class="at">(</span></span>
+<span id="cb10-65"><a href="#cb10-65" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">201</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Item créé&quot;</span><span class="op">,</span> body <span class="op">=</span> ItemInfo<span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-66"><a href="#cb10-66" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">400</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Requête invalide&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-67"><a href="#cb10-67" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">500</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Erreur serveur&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span></span>
+<span id="cb10-68"><a href="#cb10-68" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-69"><a href="#cb10-69" aria-hidden="true" tabindex="-1"></a>    tag <span class="op">=</span> <span class="st">&quot;items&quot;</span></span>
+<span id="cb10-70"><a href="#cb10-70" aria-hidden="true" tabindex="-1"></a><span class="at">)]</span></span>
+<span id="cb10-71"><a href="#cb10-71" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> create_item(</span>
+<span id="cb10-72"><a href="#cb10-72" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;,</span></span>
+<span id="cb10-73"><a href="#cb10-73" aria-hidden="true" tabindex="-1"></a>    Json(req)<span class="op">:</span> Json<span class="op">&lt;</span>CreateItemRequest<span class="op">&gt;,</span></span>
+<span id="cb10-74"><a href="#cb10-74" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>(StatusCode<span class="op">,</span> Json<span class="op">&lt;</span>ItemInfo<span class="op">&gt;</span>)<span class="op">,</span> (StatusCode<span class="op">,</span> Json<span class="op">&lt;</span>ErrorResponse<span class="op">&gt;</span>)<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb10-75"><a href="#cb10-75" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> item <span class="op">=</span> state<span class="op">.</span>resource<span class="op">.</span>create_item(req<span class="op">.</span>name<span class="op">,</span> req<span class="op">.</span>description)</span>
+<span id="cb10-76"><a href="#cb10-76" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> (</span>
+<span id="cb10-77"><a href="#cb10-77" aria-hidden="true" tabindex="-1"></a>            <span class="pp">StatusCode::</span>INTERNAL_SERVER_ERROR<span class="op">,</span></span>
+<span id="cb10-78"><a href="#cb10-78" aria-hidden="true" tabindex="-1"></a>            Json(ErrorResponse <span class="op">{</span> error<span class="op">:</span> e<span class="op">.</span>to_string() <span class="op">}</span>)</span>
+<span id="cb10-79"><a href="#cb10-79" aria-hidden="true" tabindex="-1"></a>        ))<span class="op">?;</span></span>
+<span id="cb10-80"><a href="#cb10-80" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb10-81"><a href="#cb10-81" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>((<span class="pp">StatusCode::</span>CREATED<span class="op">,</span> Json(item)))</span>
+<span id="cb10-82"><a href="#cb10-82" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb10-83"><a href="#cb10-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-84"><a href="#cb10-84" aria-hidden="true" tabindex="-1"></a><span class="co">/// DELETE /items/{id} - Supprime un item</span></span>
+<span id="cb10-85"><a href="#cb10-85" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span><span class="pp">utoipa::</span>path<span class="at">(</span></span>
+<span id="cb10-86"><a href="#cb10-86" aria-hidden="true" tabindex="-1"></a>    delete<span class="op">,</span></span>
+<span id="cb10-87"><a href="#cb10-87" aria-hidden="true" tabindex="-1"></a>    path <span class="op">=</span> <span class="st">&quot;/items/{id}&quot;</span><span class="op">,</span></span>
+<span id="cb10-88"><a href="#cb10-88" aria-hidden="true" tabindex="-1"></a>    params<span class="at">(</span></span>
+<span id="cb10-89"><a href="#cb10-89" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span><span class="st">&quot;id&quot;</span> <span class="op">=</span> <span class="dt">String</span><span class="op">,</span> <span class="dt">Path</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;ID unique de l&#39;item&quot;</span><span class="at">)</span></span>
+<span id="cb10-90"><a href="#cb10-90" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-91"><a href="#cb10-91" aria-hidden="true" tabindex="-1"></a>    responses<span class="at">(</span></span>
+<span id="cb10-92"><a href="#cb10-92" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">204</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Item supprimé&quot;</span><span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-93"><a href="#cb10-93" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">404</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Item non trouvé&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-94"><a href="#cb10-94" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">500</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Erreur serveur&quot;</span><span class="op">,</span> body <span class="op">=</span> ErrorResponse<span class="at">)</span></span>
+<span id="cb10-95"><a href="#cb10-95" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb10-96"><a href="#cb10-96" aria-hidden="true" tabindex="-1"></a>    tag <span class="op">=</span> <span class="st">&quot;items&quot;</span></span>
+<span id="cb10-97"><a href="#cb10-97" aria-hidden="true" tabindex="-1"></a><span class="at">)]</span></span>
+<span id="cb10-98"><a href="#cb10-98" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> delete_item(</span>
+<span id="cb10-99"><a href="#cb10-99" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;,</span></span>
+<span id="cb10-100"><a href="#cb10-100" aria-hidden="true" tabindex="-1"></a>    <span class="dt">Path</span>(id)<span class="op">:</span> <span class="dt">Path</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb10-101"><a href="#cb10-101" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>StatusCode<span class="op">,</span> (StatusCode<span class="op">,</span> Json<span class="op">&lt;</span>ErrorResponse<span class="op">&gt;</span>)<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb10-102"><a href="#cb10-102" aria-hidden="true" tabindex="-1"></a>    state<span class="op">.</span>resource<span class="op">.</span>delete_item(<span class="op">&amp;</span>id)</span>
+<span id="cb10-103"><a href="#cb10-103" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> (</span>
+<span id="cb10-104"><a href="#cb10-104" aria-hidden="true" tabindex="-1"></a>            <span class="pp">StatusCode::</span>INTERNAL_SERVER_ERROR<span class="op">,</span></span>
+<span id="cb10-105"><a href="#cb10-105" aria-hidden="true" tabindex="-1"></a>            Json(ErrorResponse <span class="op">{</span> error<span class="op">:</span> e<span class="op">.</span>to_string() <span class="op">}</span>)</span>
+<span id="cb10-106"><a href="#cb10-106" aria-hidden="true" tabindex="-1"></a>        ))<span class="op">?;</span></span>
+<span id="cb10-107"><a href="#cb10-107" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb10-108"><a href="#cb10-108" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>(<span class="pp">StatusCode::</span>NO_CONTENT)</span>
+<span id="cb10-109"><a href="#cb10-109" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Structure de <code>#[utoipa::path]</code></strong> : -
+<strong>Méthode HTTP</strong> : <code>get</code>, <code>post</code>,
+<code>put</code>, <code>delete</code>, <code>patch</code> -
+<strong><code>path</code></strong> : Chemin de l’endpoint (doit
+correspondre au router) - <strong><code>params</code></strong> :
+Paramètres Path ou Query avec description -
+<strong><code>request_body</code></strong> : Type du body pour POST/PUT
+- <strong><code>responses</code></strong> : Liste des réponses possibles
+avec codes HTTP - <strong><code>tag</code></strong> : Groupe d’endpoints
+dans Swagger UI</p>
+<h3 id="créer-la-structure-openapi">3. Créer la structure OpenAPI</h3>
+<p>Définir une structure avec <code>#[derive(OpenApi)]</code> :</p>
+<div class="sourceCode" id="cb11"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">utoipa::</span>OpenApi<span class="op">;</span></span>
+<span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-3"><a href="#cb11-3" aria-hidden="true" tabindex="-1"></a><span class="co">/// Documentation OpenAPI pour l&#39;API XXX</span></span>
+<span id="cb11-4"><a href="#cb11-4" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span>OpenApi<span class="at">)]</span></span>
+<span id="cb11-5"><a href="#cb11-5" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>openapi<span class="at">(</span></span>
+<span id="cb11-6"><a href="#cb11-6" aria-hidden="true" tabindex="-1"></a>    info<span class="at">(</span></span>
+<span id="cb11-7"><a href="#cb11-7" aria-hidden="true" tabindex="-1"></a>        title <span class="op">=</span> <span class="st">&quot;XXX API&quot;</span><span class="op">,</span></span>
+<span id="cb11-8"><a href="#cb11-8" aria-hidden="true" tabindex="-1"></a>        version <span class="op">=</span> <span class="st">&quot;1.0.0&quot;</span><span class="op">,</span></span>
+<span id="cb11-9"><a href="#cb11-9" aria-hidden="true" tabindex="-1"></a>        description <span class="op">=</span> <span class="st">r#&quot;</span></span>
+<span id="cb11-10"><a href="#cb11-10" aria-hidden="true" tabindex="-1"></a><span class="st"># API REST pour XXX</span></span>
+<span id="cb11-11"><a href="#cb11-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-12"><a href="#cb11-12" aria-hidden="true" tabindex="-1"></a><span class="st">Cette API permet de gérer les items XXX avec les fonctionnalités suivantes :</span></span>
+<span id="cb11-13"><a href="#cb11-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-14"><a href="#cb11-14" aria-hidden="true" tabindex="-1"></a><span class="st">## Fonctionnalités</span></span>
+<span id="cb11-15"><a href="#cb11-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-16"><a href="#cb11-16" aria-hidden="true" tabindex="-1"></a><span class="st">- **CRUD complet** : Création, lecture, mise à jour et suppression d&#39;items</span></span>
+<span id="cb11-17"><a href="#cb11-17" aria-hidden="true" tabindex="-1"></a><span class="st">- **Pagination** : Support de limit/offset pour les listes</span></span>
+<span id="cb11-18"><a href="#cb11-18" aria-hidden="true" tabindex="-1"></a><span class="st">- **Filtrage** : Recherche par critères multiples</span></span>
+<span id="cb11-19"><a href="#cb11-19" aria-hidden="true" tabindex="-1"></a><span class="st">- **Validation** : Vérification automatique des données</span></span>
+<span id="cb11-20"><a href="#cb11-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-21"><a href="#cb11-21" aria-hidden="true" tabindex="-1"></a><span class="st">## Exemples d&#39;utilisation</span></span>
+<span id="cb11-22"><a href="#cb11-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb11-23"><a href="#cb11-23" aria-hidden="true" tabindex="-1"></a><span class="st">### Lister les items</span></span></pre></div>
+<p>GET /api/xxx/items?limit=10&amp;offset=0</p>
+<pre><code>
+### Créer un item</pre>
+<p>POST /api/xxx/items Content-Type: application/json</p>
+<p>{ “name”: “Mon Item”, “description”: “Description détaillée” }</p>
+<pre><code>
+### Récupérer un item</pre>
+<p>GET /api/xxx/items/item-123</p>
+<pre><code>
+### Supprimer un item</pre>
+<p>DELETE /api/xxx/items/item-123</p>
+<pre><code>        &quot;#
+    ),
+    paths(
+        list_items,
+        get_item,
+        create_item,
+        delete_item,
+    ),
+    components(schemas(
+        ItemInfo,
+        ItemList,
+        CreateItemRequest,
+        ErrorResponse,
+    )),
+    tags(
+        (name = &quot;items&quot;, description = &quot;Opérations sur les items&quot;)
+    )
+)]
+pub struct ApiDoc;</pre>
+<p><strong>Sections importantes</strong> : -
+<strong><code>info</code></strong> : Titre, version et description
+Markdown de l’API - <strong><code>paths</code></strong> : Liste des
+fonctions handler annotées -
+<strong><code>components(schemas(...))</code></strong> : Liste des
+structures <code>ToSchema</code> - <strong><code>tags</code></strong> :
+Organisation des endpoints en groupes</p>
+<h3 id="enregistrer-lapi-avec-openapi">4. Enregistrer l’API avec
+OpenAPI</h3>
+<p>Dans l’implémentation du trait d’extension :</p>
+<div class="sourceCode" id="cb16"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb16-2"><a href="#cb16-2" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> XxxExt <span class="cf">for</span> <span class="pp">pmoserver::</span>Server <span class="op">{</span></span>
+<span id="cb16-3"><a href="#cb16-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_xxx(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>Resource<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb16-4"><a href="#cb16-4" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> resource <span class="op">=</span> <span class="pp">Arc::</span>new(<span class="pp">Resource::</span>new()<span class="op">?</span>)<span class="op">;</span></span>
+<span id="cb16-5"><a href="#cb16-5" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> state <span class="op">=</span> XxxState <span class="op">{</span> resource<span class="op">:</span> resource<span class="op">.</span>clone() <span class="op">};</span></span>
+<span id="cb16-6"><a href="#cb16-6" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb16-7"><a href="#cb16-7" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Créer le router avec les routes</span></span>
+<span id="cb16-8"><a href="#cb16-8" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> router <span class="op">=</span> <span class="pp">Router::</span>new()</span>
+<span id="cb16-9"><a href="#cb16-9" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>route(<span class="st">&quot;/items&quot;</span><span class="op">,</span> get(list_items)<span class="op">.</span>post(create_item))</span>
+<span id="cb16-10"><a href="#cb16-10" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>route(<span class="st">&quot;/items/{id}&quot;</span><span class="op">,</span> get(get_item)<span class="op">.</span>delete(delete_item))</span>
+<span id="cb16-11"><a href="#cb16-11" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>with_state(state)<span class="op">;</span></span>
+<span id="cb16-12"><a href="#cb16-12" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb16-13"><a href="#cb16-13" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Enregistrer avec OpenAPI (génère aussi /swagger-ui/xxx)</span></span>
+<span id="cb16-14"><a href="#cb16-14" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> openapi <span class="op">=</span> <span class="pp">ApiDoc::</span>openapi()<span class="op">;</span></span>
+<span id="cb16-15"><a href="#cb16-15" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_openapi(router<span class="op">,</span> openapi<span class="op">,</span> <span class="st">&quot;xxx&quot;</span>)<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb16-16"><a href="#cb16-16" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb16-17"><a href="#cb16-17" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(resource)</span>
+<span id="cb16-18"><a href="#cb16-18" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb16-19"><a href="#cb16-19" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Ce que fait <code>add_openapi</code></strong> : - Monte le
+router sur <code>/api/{tag}/</code> - Génère la spec OpenAPI JSON sur
+<code>/api/{tag}/openapi.json</code> - Crée une UI Swagger sur
+<code>/swagger-ui/{tag}/</code></p>
+<h3 id="exemple-complet-radio-paradise">5. Exemple complet : Radio
+Paradise</h3>
+<p><strong>Extrait de</strong>
+<code>pmoparadise/src/pmoserver_ext.rs:93-315</code></p>
+<div class="sourceCode" id="cb17"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a><span class="co">/// Information sur un morceau</span></span>
+<span id="cb17-2"><a href="#cb17-2" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> ToSchema<span class="at">)]</span></span>
+<span id="cb17-3"><a href="#cb17-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> SongInfo <span class="op">{</span></span>
+<span id="cb17-4"><a href="#cb17-4" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Index dans le block</span></span>
+<span id="cb17-5"><a href="#cb17-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> index<span class="op">:</span> <span class="dt">usize</span><span class="op">,</span></span>
+<span id="cb17-6"><a href="#cb17-6" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Artiste</span></span>
+<span id="cb17-7"><a href="#cb17-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> artist<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb17-8"><a href="#cb17-8" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Titre</span></span>
+<span id="cb17-9"><a href="#cb17-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> title<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb17-10"><a href="#cb17-10" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Album</span></span>
+<span id="cb17-11"><a href="#cb17-11" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> album<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb17-12"><a href="#cb17-12" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Année</span></span>
+<span id="cb17-13"><a href="#cb17-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> year<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;,</span></span>
+<span id="cb17-14"><a href="#cb17-14" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Temps écoulé depuis le début du block (ms)</span></span>
+<span id="cb17-15"><a href="#cb17-15" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> elapsed_ms<span class="op">:</span> <span class="dt">u64</span><span class="op">,</span></span>
+<span id="cb17-16"><a href="#cb17-16" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Durée du morceau (ms)</span></span>
+<span id="cb17-17"><a href="#cb17-17" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> duration_ms<span class="op">:</span> <span class="dt">u64</span><span class="op">,</span></span>
+<span id="cb17-18"><a href="#cb17-18" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// URL de la pochette</span></span>
+<span id="cb17-19"><a href="#cb17-19" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> cover_url<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb17-20"><a href="#cb17-20" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb17-21"><a href="#cb17-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb17-22"><a href="#cb17-22" aria-hidden="true" tabindex="-1"></a><span class="co">/// Réponse pour l&#39;URL de streaming</span></span>
+<span id="cb17-23"><a href="#cb17-23" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> ToSchema<span class="at">)]</span></span>
+<span id="cb17-24"><a href="#cb17-24" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> StreamUrlResponse <span class="op">{</span></span>
+<span id="cb17-25"><a href="#cb17-25" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Event ID du block</span></span>
+<span id="cb17-26"><a href="#cb17-26" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="dv">1234567</span><span class="at">)]</span></span>
+<span id="cb17-27"><a href="#cb17-27" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> event<span class="op">:</span> <span class="dt">u64</span><span class="op">,</span></span>
+<span id="cb17-28"><a href="#cb17-28" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// URL de streaming FLAC</span></span>
+<span id="cb17-29"><a href="#cb17-29" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="st">&quot;https://apps.radioparadise.com/blocks/chan/0/4/1234567-1234580.flac&quot;</span><span class="at">)]</span></span>
+<span id="cb17-30"><a href="#cb17-30" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> stream_url<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb17-31"><a href="#cb17-31" aria-hidden="true" tabindex="-1"></a>    <span class="co">/// Durée totale (ms)</span></span>
+<span id="cb17-32"><a href="#cb17-32" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>schema<span class="at">(</span>example <span class="op">=</span> <span class="dv">900000</span><span class="at">)]</span></span>
+<span id="cb17-33"><a href="#cb17-33" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> length_ms<span class="op">:</span> <span class="dt">u64</span><span class="op">,</span></span>
+<span id="cb17-34"><a href="#cb17-34" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb17-35"><a href="#cb17-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb17-36"><a href="#cb17-36" aria-hidden="true" tabindex="-1"></a><span class="co">/// GET /stream-url/{event_id} - Récupère l&#39;URL de streaming</span></span>
+<span id="cb17-37"><a href="#cb17-37" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span><span class="pp">utoipa::</span>path<span class="at">(</span></span>
+<span id="cb17-38"><a href="#cb17-38" aria-hidden="true" tabindex="-1"></a>    get<span class="op">,</span></span>
+<span id="cb17-39"><a href="#cb17-39" aria-hidden="true" tabindex="-1"></a>    path <span class="op">=</span> <span class="st">&quot;/stream-url/{event_id}&quot;</span><span class="op">,</span></span>
+<span id="cb17-40"><a href="#cb17-40" aria-hidden="true" tabindex="-1"></a>    params<span class="at">(</span></span>
+<span id="cb17-41"><a href="#cb17-41" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span><span class="st">&quot;event_id&quot;</span> <span class="op">=</span> <span class="dt">u64</span><span class="op">,</span> <span class="dt">Path</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Event ID du block&quot;</span><span class="at">)</span><span class="op">,</span></span>
+<span id="cb17-42"><a href="#cb17-42" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span><span class="st">&quot;channel&quot;</span> <span class="op">=</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">u8</span><span class="op">&gt;,</span> Query<span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Channel ID (0-3)&quot;</span><span class="at">)</span></span>
+<span id="cb17-43"><a href="#cb17-43" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb17-44"><a href="#cb17-44" aria-hidden="true" tabindex="-1"></a>    responses<span class="at">(</span></span>
+<span id="cb17-45"><a href="#cb17-45" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">200</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;URL de streaming&quot;</span><span class="op">,</span> body <span class="op">=</span> StreamUrlResponse<span class="at">)</span><span class="op">,</span></span>
+<span id="cb17-46"><a href="#cb17-46" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>status <span class="op">=</span> <span class="dv">500</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Erreur serveur&quot;</span><span class="at">)</span></span>
+<span id="cb17-47"><a href="#cb17-47" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb17-48"><a href="#cb17-48" aria-hidden="true" tabindex="-1"></a>    tag <span class="op">=</span> <span class="st">&quot;Radio Paradise&quot;</span></span>
+<span id="cb17-49"><a href="#cb17-49" aria-hidden="true" tabindex="-1"></a><span class="at">)]</span></span>
+<span id="cb17-50"><a href="#cb17-50" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> get_stream_url(</span>
+<span id="cb17-51"><a href="#cb17-51" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>RadioParadiseState<span class="op">&gt;,</span></span>
+<span id="cb17-52"><a href="#cb17-52" aria-hidden="true" tabindex="-1"></a>    <span class="dt">Path</span>(event_id)<span class="op">:</span> <span class="dt">Path</span><span class="op">&lt;</span><span class="dt">u64</span><span class="op">&gt;,</span></span>
+<span id="cb17-53"><a href="#cb17-53" aria-hidden="true" tabindex="-1"></a>    Query(params)<span class="op">:</span> Query<span class="op">&lt;</span>ParadiseQuery<span class="op">&gt;,</span></span>
+<span id="cb17-54"><a href="#cb17-54" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Json<span class="op">&lt;</span>StreamUrlResponse<span class="op">&gt;,</span> StatusCode<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb17-55"><a href="#cb17-55" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> client <span class="op">=</span> state<span class="op">.</span>client_for_params(<span class="op">&amp;</span>params)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb17-56"><a href="#cb17-56" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> block <span class="op">=</span> client<span class="op">.</span>get_block(<span class="cn">Some</span>(event_id))<span class="op">.</span><span class="kw">await</span><span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="op">{</span></span>
+<span id="cb17-57"><a href="#cb17-57" aria-hidden="true" tabindex="-1"></a>        <span class="pp">tracing::error!</span>(<span class="st">&quot;Failed to fetch block {}: {}&quot;</span><span class="op">,</span> event_id<span class="op">,</span> e)<span class="op">;</span></span>
+<span id="cb17-58"><a href="#cb17-58" aria-hidden="true" tabindex="-1"></a>        <span class="pp">StatusCode::</span>INTERNAL_SERVER_ERROR</span>
+<span id="cb17-59"><a href="#cb17-59" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span>)<span class="op">?;</span></span>
+<span id="cb17-60"><a href="#cb17-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb17-61"><a href="#cb17-61" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>(Json(StreamUrlResponse <span class="op">{</span></span>
+<span id="cb17-62"><a href="#cb17-62" aria-hidden="true" tabindex="-1"></a>        event<span class="op">:</span> block<span class="op">.</span>event<span class="op">,</span></span>
+<span id="cb17-63"><a href="#cb17-63" aria-hidden="true" tabindex="-1"></a>        stream_url<span class="op">:</span> block<span class="op">.</span>url<span class="op">,</span></span>
+<span id="cb17-64"><a href="#cb17-64" aria-hidden="true" tabindex="-1"></a>        length_ms<span class="op">:</span> block<span class="op">.</span>length<span class="op">,</span></span>
+<span id="cb17-65"><a href="#cb17-65" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span>))</span>
+<span id="cb17-66"><a href="#cb17-66" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb17-67"><a href="#cb17-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb17-68"><a href="#cb17-68" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span>OpenApi<span class="at">)]</span></span>
+<span id="cb17-69"><a href="#cb17-69" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>openapi<span class="at">(</span></span>
+<span id="cb17-70"><a href="#cb17-70" aria-hidden="true" tabindex="-1"></a>    info<span class="at">(</span></span>
+<span id="cb17-71"><a href="#cb17-71" aria-hidden="true" tabindex="-1"></a>        title <span class="op">=</span> <span class="st">&quot;Radio Paradise API&quot;</span><span class="op">,</span></span>
+<span id="cb17-72"><a href="#cb17-72" aria-hidden="true" tabindex="-1"></a>        version <span class="op">=</span> <span class="st">&quot;1.0.0&quot;</span><span class="op">,</span></span>
+<span id="cb17-73"><a href="#cb17-73" aria-hidden="true" tabindex="-1"></a>        description <span class="op">=</span> <span class="st">&quot;API REST pour accéder aux métadonnées Radio Paradise&quot;</span></span>
+<span id="cb17-74"><a href="#cb17-74" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb17-75"><a href="#cb17-75" aria-hidden="true" tabindex="-1"></a>    paths<span class="at">(</span></span>
+<span id="cb17-76"><a href="#cb17-76" aria-hidden="true" tabindex="-1"></a>        get_now_playing<span class="op">,</span></span>
+<span id="cb17-77"><a href="#cb17-77" aria-hidden="true" tabindex="-1"></a>        get_current_block<span class="op">,</span></span>
+<span id="cb17-78"><a href="#cb17-78" aria-hidden="true" tabindex="-1"></a>        get_stream_url<span class="op">,</span></span>
+<span id="cb17-79"><a href="#cb17-79" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span><span class="op">,</span></span>
+<span id="cb17-80"><a href="#cb17-80" aria-hidden="true" tabindex="-1"></a>    components<span class="at">(</span>schemas<span class="at">(</span></span>
+<span id="cb17-81"><a href="#cb17-81" aria-hidden="true" tabindex="-1"></a>        SongInfo<span class="op">,</span></span>
+<span id="cb17-82"><a href="#cb17-82" aria-hidden="true" tabindex="-1"></a>        StreamUrlResponse<span class="op">,</span></span>
+<span id="cb17-83"><a href="#cb17-83" aria-hidden="true" tabindex="-1"></a>    <span class="at">))</span><span class="op">,</span></span>
+<span id="cb17-84"><a href="#cb17-84" aria-hidden="true" tabindex="-1"></a>    tags<span class="at">(</span></span>
+<span id="cb17-85"><a href="#cb17-85" aria-hidden="true" tabindex="-1"></a>        <span class="at">(</span>name <span class="op">=</span> <span class="st">&quot;Radio Paradise&quot;</span><span class="op">,</span> description <span class="op">=</span> <span class="st">&quot;Endpoints Radio Paradise&quot;</span><span class="at">)</span></span>
+<span id="cb17-86"><a href="#cb17-86" aria-hidden="true" tabindex="-1"></a>    <span class="at">)</span></span>
+<span id="cb17-87"><a href="#cb17-87" aria-hidden="true" tabindex="-1"></a><span class="at">)]</span></span>
+<span id="cb17-88"><a href="#cb17-88" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> RadioParadiseApiDoc<span class="op">;</span></span></pre></div>
+<h3 id="résultat-interface-swagger">Résultat : Interface Swagger</h3>
+<p>Après avoir appelé <code>init_xxx()</code>, l’API est accessible
+:</p>
+<ul>
+<li><strong>API JSON</strong> :
+<code>http://localhost:8080/api/xxx/</code></li>
+<li><strong>Spec OpenAPI</strong> :
+<code>http://localhost:8080/api/xxx/openapi.json</code></li>
+<li><strong>Swagger UI</strong> :
+<code>http://localhost:8080/swagger-ui/xxx/</code></li>
+</ul>
+<p>L’interface Swagger permet : - Parcourir tous les endpoints avec leur
+documentation - Tester les requêtes directement depuis le navigateur -
+Voir les schémas de données avec exemples - Consulter les codes de
+réponse HTTP possibles</p>
+<h2 id="patterns-courants">Patterns courants</h2>
+<h3 id="pattern-1-extension-simple-avec-router">Pattern 1 : Extension
+simple avec router</h3>
+<p><strong>Exemple</strong> : <code>pmoparadise</code>
+(pmoparadise/src/pmoserver_ext.rs:367-392)</p>
+<div class="sourceCode" id="cb18"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb18-1"><a href="#cb18-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb18-2"><a href="#cb18-2" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> RadioParadiseExt <span class="cf">for</span> <span class="pp">pmoserver::</span>Server <span class="op">{</span></span>
+<span id="cb18-3"><a href="#cb18-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_radioparadise(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>State<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb18-4"><a href="#cb18-4" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> state <span class="op">=</span> <span class="pp">RadioParadiseState::</span>new()<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb18-5"><a href="#cb18-5" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb18-6"><a href="#cb18-6" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Créer le router API</span></span>
+<span id="cb18-7"><a href="#cb18-7" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> api_router <span class="op">=</span> create_api_router(state<span class="op">.</span>clone())<span class="op">;</span></span>
+<span id="cb18-8"><a href="#cb18-8" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb18-9"><a href="#cb18-9" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Enregistrer avec OpenAPI</span></span>
+<span id="cb18-10"><a href="#cb18-10" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_openapi(api_router<span class="op">,</span> <span class="pp">ApiDoc::</span>openapi()<span class="op">,</span> <span class="st">&quot;radioparadise&quot;</span>)</span>
+<span id="cb18-11"><a href="#cb18-11" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb18-12"><a href="#cb18-12" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb18-13"><a href="#cb18-13" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(state)</span>
+<span id="cb18-14"><a href="#cb18-14" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-15"><a href="#cb18-15" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="pattern-2-extension-avec-cache-et-fichiers">Pattern 2 :
+Extension avec cache et fichiers</h3>
+<p><strong>Exemple</strong> : <code>pmoaudiocache</code>
+(pmoaudiocache/src/lib.rs:225-260)</p>
+<div class="sourceCode" id="cb19"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb19-1"><a href="#cb19-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb19-2"><a href="#cb19-2" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> AudioCacheExt <span class="cf">for</span> <span class="pp">pmoserver::</span>Server <span class="op">{</span></span>
+<span id="cb19-3"><a href="#cb19-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_audio_cache(</span>
+<span id="cb19-4"><a href="#cb19-4" aria-hidden="true" tabindex="-1"></a>        <span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span><span class="op">,</span></span>
+<span id="cb19-5"><a href="#cb19-5" aria-hidden="true" tabindex="-1"></a>        cache_dir<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span><span class="op">,</span></span>
+<span id="cb19-6"><a href="#cb19-6" aria-hidden="true" tabindex="-1"></a>        limit<span class="op">:</span> <span class="dt">usize</span><span class="op">,</span></span>
+<span id="cb19-7"><a href="#cb19-7" aria-hidden="true" tabindex="-1"></a>    ) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>Cache<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb19-8"><a href="#cb19-8" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> cache <span class="op">=</span> <span class="pp">Arc::</span>new(new_cache(cache_dir<span class="op">,</span> limit)<span class="op">?</span>)<span class="op">;</span></span>
+<span id="cb19-9"><a href="#cb19-9" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb19-10"><a href="#cb19-10" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Router pour servir les fichiers FLAC</span></span>
+<span id="cb19-11"><a href="#cb19-11" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> file_router <span class="op">=</span> create_file_router(cache<span class="op">.</span>clone()<span class="op">,</span> <span class="st">&quot;audio/flac&quot;</span>)<span class="op">;</span></span>
+<span id="cb19-12"><a href="#cb19-12" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_router(<span class="st">&quot;/&quot;</span><span class="op">,</span> file_router)<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb19-13"><a href="#cb19-13" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb19-14"><a href="#cb19-14" aria-hidden="true" tabindex="-1"></a>        <span class="co">// API REST</span></span>
+<span id="cb19-15"><a href="#cb19-15" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> api_router <span class="op">=</span> <span class="pp">Router::</span>new()</span>
+<span id="cb19-16"><a href="#cb19-16" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>route(<span class="st">&quot;/&quot;</span><span class="op">,</span> get(list)<span class="op">.</span>post(add))</span>
+<span id="cb19-17"><a href="#cb19-17" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>route(<span class="st">&quot;/{pk}&quot;</span><span class="op">,</span> get(get_info)<span class="op">.</span>delete(delete))</span>
+<span id="cb19-18"><a href="#cb19-18" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>with_state(cache<span class="op">.</span>clone())<span class="op">;</span></span>
+<span id="cb19-19"><a href="#cb19-19" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb19-20"><a href="#cb19-20" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_openapi(api_router<span class="op">,</span> <span class="pp">ApiDoc::</span>openapi()<span class="op">,</span> <span class="st">&quot;audio&quot;</span>)<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb19-21"><a href="#cb19-21" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb19-22"><a href="#cb19-22" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(cache)</span>
+<span id="cb19-23"><a href="#cb19-23" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb19-24"><a href="#cb19-24" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="pattern-3-extension-avec-routes-dynamiques">Pattern 3 :
+Extension avec routes dynamiques</h3>
+<p><strong>Exemple</strong> : <code>pmomediaserver</code>
+(pmomediaserver/src/paradise_streaming.rs:70-148)</p>
+<div class="sourceCode" id="cb20"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb20-1"><a href="#cb20-1" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb20-2"><a href="#cb20-2" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> ParadiseStreamingExt <span class="cf">for</span> <span class="pp">pmoserver::</span>Server <span class="op">{</span></span>
+<span id="cb20-3"><a href="#cb20-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_paradise_streaming(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>Manager<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb20-4"><a href="#cb20-4" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 1. Récupérer/créer les ressources partagées</span></span>
+<span id="cb20-5"><a href="#cb20-5" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> audio_cache <span class="op">=</span> get_or_init_audio_cache(<span class="kw">self</span>)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb20-6"><a href="#cb20-6" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> manager <span class="op">=</span> <span class="pp">Arc::</span>new(<span class="pp">Manager::</span>new(audio_cache)<span class="op">.</span><span class="kw">await</span><span class="op">?</span>)<span class="op">;</span></span>
+<span id="cb20-7"><a href="#cb20-7" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb20-8"><a href="#cb20-8" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 2. Créer l&#39;état partagé</span></span>
+<span id="cb20-9"><a href="#cb20-9" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> state <span class="op">=</span> <span class="pp">Arc::</span>new(StreamingState <span class="op">{</span> manager<span class="op">:</span> manager<span class="op">.</span>clone() <span class="op">}</span>)<span class="op">;</span></span>
+<span id="cb20-10"><a href="#cb20-10" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb20-11"><a href="#cb20-11" aria-hidden="true" tabindex="-1"></a>        <span class="co">// 3. Enregistrer les routes pour chaque canal</span></span>
+<span id="cb20-12"><a href="#cb20-12" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> descriptor <span class="kw">in</span> ALL_CHANNELS<span class="op">.</span>iter() <span class="op">{</span></span>
+<span id="cb20-13"><a href="#cb20-13" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> slug <span class="op">=</span> descriptor<span class="op">.</span>slug<span class="op">;</span></span>
+<span id="cb20-14"><a href="#cb20-14" aria-hidden="true" tabindex="-1"></a>            </span>
+<span id="cb20-15"><a href="#cb20-15" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Route streaming FLAC</span></span>
+<span id="cb20-16"><a href="#cb20-16" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> path <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;/stream/{}/flac&quot;</span><span class="op">,</span> slug)<span class="op">;</span></span>
+<span id="cb20-17"><a href="#cb20-17" aria-hidden="true" tabindex="-1"></a>            <span class="kw">self</span><span class="op">.</span>add_handler_with_state(</span>
+<span id="cb20-18"><a href="#cb20-18" aria-hidden="true" tabindex="-1"></a>                <span class="op">&amp;</span>path<span class="op">,</span></span>
+<span id="cb20-19"><a href="#cb20-19" aria-hidden="true" tabindex="-1"></a>                <span class="kw">move</span> <span class="op">|</span>State(s)<span class="op">:</span> State<span class="op">&lt;</span>Arc<span class="op">&lt;</span>StreamingState<span class="op">&gt;&gt;|</span> <span class="kw">async</span> <span class="kw">move</span> <span class="op">{</span></span>
+<span id="cb20-20"><a href="#cb20-20" aria-hidden="true" tabindex="-1"></a>                    stream_flac(s<span class="op">.</span>manager<span class="op">.</span>clone()<span class="op">,</span> descriptor<span class="op">.</span>id)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb20-21"><a href="#cb20-21" aria-hidden="true" tabindex="-1"></a>                <span class="op">},</span></span>
+<span id="cb20-22"><a href="#cb20-22" aria-hidden="true" tabindex="-1"></a>                state<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb20-23"><a href="#cb20-23" aria-hidden="true" tabindex="-1"></a>            )<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb20-24"><a href="#cb20-24" aria-hidden="true" tabindex="-1"></a>            </span>
+<span id="cb20-25"><a href="#cb20-25" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Route streaming OGG</span></span>
+<span id="cb20-26"><a href="#cb20-26" aria-hidden="true" tabindex="-1"></a>            <span class="kw">let</span> path <span class="op">=</span> <span class="pp">format!</span>(<span class="st">&quot;/stream/{}/ogg&quot;</span><span class="op">,</span> slug)<span class="op">;</span></span>
+<span id="cb20-27"><a href="#cb20-27" aria-hidden="true" tabindex="-1"></a>            <span class="kw">self</span><span class="op">.</span>add_handler_with_state(</span>
+<span id="cb20-28"><a href="#cb20-28" aria-hidden="true" tabindex="-1"></a>                <span class="op">&amp;</span>path<span class="op">,</span></span>
+<span id="cb20-29"><a href="#cb20-29" aria-hidden="true" tabindex="-1"></a>                <span class="kw">move</span> <span class="op">|</span>State(s)<span class="op">:</span> State<span class="op">&lt;</span>Arc<span class="op">&lt;</span>StreamingState<span class="op">&gt;&gt;|</span> <span class="kw">async</span> <span class="kw">move</span> <span class="op">{</span></span>
+<span id="cb20-30"><a href="#cb20-30" aria-hidden="true" tabindex="-1"></a>                    stream_ogg(s<span class="op">.</span>manager<span class="op">.</span>clone()<span class="op">,</span> descriptor<span class="op">.</span>id)<span class="op">.</span><span class="kw">await</span></span>
+<span id="cb20-31"><a href="#cb20-31" aria-hidden="true" tabindex="-1"></a>                <span class="op">},</span></span>
+<span id="cb20-32"><a href="#cb20-32" aria-hidden="true" tabindex="-1"></a>                state<span class="op">.</span>clone()<span class="op">,</span></span>
+<span id="cb20-33"><a href="#cb20-33" aria-hidden="true" tabindex="-1"></a>            )<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb20-34"><a href="#cb20-34" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb20-35"><a href="#cb20-35" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb20-36"><a href="#cb20-36" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(manager)</span>
+<span id="cb20-37"><a href="#cb20-37" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb20-38"><a href="#cb20-38" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h2 id="gestion-des-opérations-longues">Gestion des opérations
+longues</h2>
+<h3 id="utiliser-spawn_blocking-pour-le-code-synchrone">Utiliser
+<code>spawn_blocking</code> pour le code synchrone</h3>
+<p>Pour éviter de bloquer le runtime Tokio avec du code synchrone :</p>
+<div class="sourceCode" id="cb21"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb21-1"><a href="#cb21-1" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> list_renderers(</span>
+<span id="cb21-2"><a href="#cb21-2" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>ControlPointState<span class="op">&gt;</span></span>
+<span id="cb21-3"><a href="#cb21-3" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> Json<span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span>Summary<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb21-4"><a href="#cb21-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> control_point <span class="op">=</span> state<span class="op">.</span>control_point<span class="op">.</span>clone()<span class="op">;</span></span>
+<span id="cb21-5"><a href="#cb21-5" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb21-6"><a href="#cb21-6" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> summaries <span class="op">=</span> <span class="pp">tokio::task::</span>spawn_blocking(<span class="kw">move</span> <span class="op">||</span> <span class="op">{</span></span>
+<span id="cb21-7"><a href="#cb21-7" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> renderers <span class="op">=</span> control_point<span class="op">.</span>list_music_renderers()<span class="op">;</span></span>
+<span id="cb21-8"><a href="#cb21-8" aria-hidden="true" tabindex="-1"></a>        renderers<span class="op">.</span>into_iter()</span>
+<span id="cb21-9"><a href="#cb21-9" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map(<span class="op">|</span>r<span class="op">|</span> <span class="pp">Summary::</span>from(<span class="op">&amp;</span>r))</span>
+<span id="cb21-10"><a href="#cb21-10" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>collect()</span>
+<span id="cb21-11"><a href="#cb21-11" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span>)</span>
+<span id="cb21-12"><a href="#cb21-12" aria-hidden="true" tabindex="-1"></a>    <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb21-13"><a href="#cb21-13" aria-hidden="true" tabindex="-1"></a>    <span class="op">.</span>unwrap_or_default()<span class="op">;</span></span>
+<span id="cb21-14"><a href="#cb21-14" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb21-15"><a href="#cb21-15" aria-hidden="true" tabindex="-1"></a>    Json(summaries)</span>
+<span id="cb21-16"><a href="#cb21-16" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="ajouter-des-timeouts-pour-les-opérations-réseau">Ajouter des
+timeouts pour les opérations réseau</h3>
+<div class="sourceCode" id="cb22"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb22-1"><a href="#cb22-1" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> COMMAND_TIMEOUT<span class="op">:</span> Duration <span class="op">=</span> <span class="pp">Duration::</span>from_secs(<span class="dv">5</span>)<span class="op">;</span></span>
+<span id="cb22-2"><a href="#cb22-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb22-3"><a href="#cb22-3" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> play_renderer(</span>
+<span id="cb22-4"><a href="#cb22-4" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>ControlPointState<span class="op">&gt;,</span></span>
+<span id="cb22-5"><a href="#cb22-5" aria-hidden="true" tabindex="-1"></a>    <span class="dt">Path</span>(id)<span class="op">:</span> <span class="dt">Path</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb22-6"><a href="#cb22-6" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Json<span class="op">&lt;</span>Response<span class="op">&gt;,</span> (StatusCode<span class="op">,</span> Json<span class="op">&lt;</span><span class="bu">Error</span><span class="op">&gt;</span>)<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb22-7"><a href="#cb22-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> renderer <span class="op">=</span> state<span class="op">.</span>get_renderer(<span class="op">&amp;</span>id)</span>
+<span id="cb22-8"><a href="#cb22-8" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>ok_or((<span class="pp">StatusCode::</span>NOT_FOUND<span class="op">,</span> Json(<span class="bu">Error</span><span class="pp">::</span>not_found())))<span class="op">?;</span></span>
+<span id="cb22-9"><a href="#cb22-9" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb22-10"><a href="#cb22-10" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> play_task <span class="op">=</span> <span class="pp">tokio::task::</span>spawn_blocking(<span class="kw">move</span> <span class="op">||</span> renderer<span class="op">.</span>play())<span class="op">;</span></span>
+<span id="cb22-11"><a href="#cb22-11" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb22-12"><a href="#cb22-12" aria-hidden="true" tabindex="-1"></a>    <span class="pp">time::</span>timeout(COMMAND_TIMEOUT<span class="op">,</span> play_task)</span>
+<span id="cb22-13"><a href="#cb22-13" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span><span class="kw">await</span></span>
+<span id="cb22-14"><a href="#cb22-14" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map_err(<span class="op">|</span>_<span class="op">|</span> (</span>
+<span id="cb22-15"><a href="#cb22-15" aria-hidden="true" tabindex="-1"></a>            <span class="pp">StatusCode::</span>GATEWAY_TIMEOUT<span class="op">,</span></span>
+<span id="cb22-16"><a href="#cb22-16" aria-hidden="true" tabindex="-1"></a>            Json(<span class="bu">Error</span><span class="pp">::</span>timeout())</span>
+<span id="cb22-17"><a href="#cb22-17" aria-hidden="true" tabindex="-1"></a>        ))<span class="op">?</span></span>
+<span id="cb22-18"><a href="#cb22-18" aria-hidden="true" tabindex="-1"></a>        <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> (</span>
+<span id="cb22-19"><a href="#cb22-19" aria-hidden="true" tabindex="-1"></a>            <span class="pp">StatusCode::</span>INTERNAL_SERVER_ERROR<span class="op">,</span></span>
+<span id="cb22-20"><a href="#cb22-20" aria-hidden="true" tabindex="-1"></a>            Json(<span class="bu">Error</span><span class="pp">::</span>internal(e))</span>
+<span id="cb22-21"><a href="#cb22-21" aria-hidden="true" tabindex="-1"></a>        ))<span class="op">??;</span></span>
+<span id="cb22-22"><a href="#cb22-22" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb22-23"><a href="#cb22-23" aria-hidden="true" tabindex="-1"></a>    <span class="cn">Ok</span>(Json(<span class="pp">Response::</span>success()))</span>
+<span id="cb22-24"><a href="#cb22-24" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="utiliser-spawn-pour-les-tâches-en-arrière-plan">Utiliser
+<code>spawn</code> pour les tâches en arrière-plan</h3>
+<p>Pour les opérations qui ne nécessitent pas d’attendre le résultat
+:</p>
+<div class="sourceCode" id="cb23"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb23-1"><a href="#cb23-1" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> trigger_action(</span>
+<span id="cb23-2"><a href="#cb23-2" aria-hidden="true" tabindex="-1"></a>    State(state)<span class="op">:</span> State<span class="op">&lt;</span>XxxState<span class="op">&gt;,</span></span>
+<span id="cb23-3"><a href="#cb23-3" aria-hidden="true" tabindex="-1"></a>    Json(req)<span class="op">:</span> Json<span class="op">&lt;</span>Request<span class="op">&gt;,</span></span>
+<span id="cb23-4"><a href="#cb23-4" aria-hidden="true" tabindex="-1"></a>) <span class="op">-&gt;</span> Json<span class="op">&lt;</span>Response<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb23-5"><a href="#cb23-5" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Valider la requête</span></span>
+<span id="cb23-6"><a href="#cb23-6" aria-hidden="true" tabindex="-1"></a>    state<span class="op">.</span>validate(<span class="op">&amp;</span>req)<span class="op">?;</span></span>
+<span id="cb23-7"><a href="#cb23-7" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb23-8"><a href="#cb23-8" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Lancer l&#39;action en arrière-plan</span></span>
+<span id="cb23-9"><a href="#cb23-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> state_clone <span class="op">=</span> state<span class="op">.</span>clone()<span class="op">;</span></span>
+<span id="cb23-10"><a href="#cb23-10" aria-hidden="true" tabindex="-1"></a>    <span class="pp">tokio::task::</span>spawn(<span class="kw">async</span> <span class="kw">move</span> <span class="op">{</span></span>
+<span id="cb23-11"><a href="#cb23-11" aria-hidden="true" tabindex="-1"></a>        <span class="cf">match</span> state_clone<span class="op">.</span>perform_action(req)<span class="op">.</span><span class="kw">await</span> <span class="op">{</span></span>
+<span id="cb23-12"><a href="#cb23-12" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Ok</span>(_) <span class="op">=&gt;</span> <span class="pp">debug!</span>(<span class="st">&quot;Action completed&quot;</span>)<span class="op">,</span></span>
+<span id="cb23-13"><a href="#cb23-13" aria-hidden="true" tabindex="-1"></a>            <span class="cn">Err</span>(e) <span class="op">=&gt;</span> <span class="pp">warn!</span>(<span class="st">&quot;Action failed: {}&quot;</span><span class="op">,</span> e)<span class="op">,</span></span>
+<span id="cb23-14"><a href="#cb23-14" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span></span>
+<span id="cb23-15"><a href="#cb23-15" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span>)<span class="op">;</span></span>
+<span id="cb23-16"><a href="#cb23-16" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb23-17"><a href="#cb23-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">// Retourner immédiatement</span></span>
+<span id="cb23-18"><a href="#cb23-18" aria-hidden="true" tabindex="-1"></a>    Json(<span class="pp">Response::</span>accepted())</span>
+<span id="cb23-19"><a href="#cb23-19" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h2 id="checklist-dimplémentation">Checklist d’implémentation</h2>
+<h3 id="configuration-de-base-1">Configuration de base</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Créer le module
+<code>pmoserver_ext.rs</code> avec
+<code>#[cfg(feature = "pmoserver")]</code></label></li>
+<li><label><input type="checkbox" />Ajouter la feature
+<code>pmoserver</code> dans <code>Cargo.toml</code> avec dépendances
+optionnelles</label></li>
+<li><label><input type="checkbox" />Re-exporter le trait dans
+<code>lib.rs</code></label></li>
+</ul>
+<h3 id="définition-du-trait">Définition du trait</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Définir le trait
+<code>{Domaine}Ext</code> avec méthode <code>init_*</code></label></li>
+<li><label><input type="checkbox" />Créer la structure
+<code>{Domaine}State</code> avec
+<code>#[derive(Clone)]</code></label></li>
+<li><label><input type="checkbox" />Implémenter le trait pour
+<code>pmoserver::Server</code></label></li>
+</ul>
+<h3 id="documentation-openapi">Documentation OpenAPI</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Ajouter <code>utoipa</code> dans les
+dépendances</label></li>
+<li><label><input type="checkbox" />Définir les schémas de
+réponse/requête avec <code>#[derive(ToSchema)]</code></label></li>
+<li><label><input type="checkbox" />Ajouter des exemples avec
+<code>#[schema(example = "...")]</code></label></li>
+<li><label><input type="checkbox" />Annoter chaque handler avec
+<code>#[utoipa::path(...)]</code></label></li>
+<li><label><input type="checkbox" />Créer la structure
+<code>#[derive(OpenApi)]</code> avec documentation complète</label></li>
+<li><label><input type="checkbox" />Lister tous les paths et schemas
+dans <code>#[openapi(...)]</code></label></li>
+</ul>
+<h3 id="handlers-et-routes">Handlers et routes</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Créer les handlers avec les
+extracteurs Axum appropriés</label></li>
+<li><label><input type="checkbox" />Gérer les erreurs avec des codes
+HTTP sémantiques</label></li>
+<li><label><input type="checkbox" />Créer le router et l’enregistrer
+avec <code>add_openapi()</code></label></li>
+<li><label><input type="checkbox" />Ajouter des logs (debug, info, warn,
+error)</label></li>
+</ul>
+<h3 id="performance-et-robustesse">Performance et robustesse</h3>
+<ul class="task-list">
+<li><label><input type="checkbox" />Utiliser <code>spawn_blocking</code>
+pour le code synchrone</label></li>
+<li><label><input type="checkbox" />Ajouter des timeouts pour les
+opérations réseau</label></li>
+<li><label><input type="checkbox" />Utiliser <code>spawn</code> pour les
+tâches en arrière-plan si nécessaire</label></li>
+</ul>
+<h2 id="exemple-complet-minimal">Exemple complet minimal</h2>
+<div class="sourceCode" id="cb24"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb24-1"><a href="#cb24-1" aria-hidden="true" tabindex="-1"></a><span class="co">// pmoexample/src/pmoserver_ext.rs</span></span>
+<span id="cb24-2"><a href="#cb24-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb24-3"><a href="#cb24-3" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-4"><a href="#cb24-4" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">async_trait::</span>async_trait<span class="op">;</span></span>
+<span id="cb24-5"><a href="#cb24-5" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-6"><a href="#cb24-6" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">axum::</span><span class="op">{</span>Router<span class="op">,</span> <span class="pp">routing::</span>get<span class="op">,</span> Json<span class="op">,</span> <span class="pp">extract::</span>State<span class="op">};</span></span>
+<span id="cb24-7"><a href="#cb24-7" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-8"><a href="#cb24-8" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">std::sync::</span>Arc<span class="op">;</span></span>
+<span id="cb24-9"><a href="#cb24-9" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-10"><a href="#cb24-10" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="kw">crate</span><span class="pp">::</span>ExampleResource<span class="op">;</span></span>
+<span id="cb24-11"><a href="#cb24-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb24-12"><a href="#cb24-12" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-13"><a href="#cb24-13" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Clone</span><span class="at">)]</span></span>
+<span id="cb24-14"><a href="#cb24-14" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ExampleState <span class="op">{</span></span>
+<span id="cb24-15"><a href="#cb24-15" aria-hidden="true" tabindex="-1"></a>    resource<span class="op">:</span> Arc<span class="op">&lt;</span>ExampleResource<span class="op">&gt;,</span></span>
+<span id="cb24-16"><a href="#cb24-16" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb24-17"><a href="#cb24-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb24-18"><a href="#cb24-18" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-19"><a href="#cb24-19" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb24-20"><a href="#cb24-20" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">trait</span> ExampleExt <span class="op">{</span></span>
+<span id="cb24-21"><a href="#cb24-21" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_example(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>ExampleResource<span class="op">&gt;&gt;;</span></span>
+<span id="cb24-22"><a href="#cb24-22" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb24-23"><a href="#cb24-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb24-24"><a href="#cb24-24" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-25"><a href="#cb24-25" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>async_trait<span class="at">]</span></span>
+<span id="cb24-26"><a href="#cb24-26" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> ExampleExt <span class="cf">for</span> <span class="pp">pmoserver::</span>Server <span class="op">{</span></span>
+<span id="cb24-27"><a href="#cb24-27" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> <span class="kw">fn</span> init_example(<span class="op">&amp;</span><span class="kw">mut</span> <span class="kw">self</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span>ExampleResource<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb24-28"><a href="#cb24-28" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> resource <span class="op">=</span> <span class="pp">Arc::</span>new(<span class="pp">ExampleResource::</span>new())<span class="op">;</span></span>
+<span id="cb24-29"><a href="#cb24-29" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> state <span class="op">=</span> ExampleState <span class="op">{</span> resource<span class="op">:</span> resource<span class="op">.</span>clone() <span class="op">};</span></span>
+<span id="cb24-30"><a href="#cb24-30" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb24-31"><a href="#cb24-31" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> router <span class="op">=</span> <span class="pp">Router::</span>new()</span>
+<span id="cb24-32"><a href="#cb24-32" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>route(<span class="st">&quot;/items&quot;</span><span class="op">,</span> get(list_items))</span>
+<span id="cb24-33"><a href="#cb24-33" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>with_state(state)<span class="op">;</span></span>
+<span id="cb24-34"><a href="#cb24-34" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb24-35"><a href="#cb24-35" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>add_router(<span class="st">&quot;/api/example&quot;</span><span class="op">,</span> router)<span class="op">.</span><span class="kw">await</span><span class="op">;</span></span>
+<span id="cb24-36"><a href="#cb24-36" aria-hidden="true" tabindex="-1"></a>        </span>
+<span id="cb24-37"><a href="#cb24-37" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(resource)</span>
+<span id="cb24-38"><a href="#cb24-38" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb24-39"><a href="#cb24-39" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb24-40"><a href="#cb24-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb24-41"><a href="#cb24-41" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>cfg<span class="at">(</span>feature <span class="op">=</span> <span class="st">&quot;pmoserver&quot;</span><span class="at">)]</span></span>
+<span id="cb24-42"><a href="#cb24-42" aria-hidden="true" tabindex="-1"></a><span class="kw">async</span> <span class="kw">fn</span> list_items(State(state)<span class="op">:</span> State<span class="op">&lt;</span>ExampleState<span class="op">&gt;</span>) <span class="op">-&gt;</span> Json<span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;&gt;</span> <span class="op">{</span></span>
+<span id="cb24-43"><a href="#cb24-43" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> items <span class="op">=</span> state<span class="op">.</span>resource<span class="op">.</span>list()<span class="op">;</span></span>
+<span id="cb24-44"><a href="#cb24-44" aria-hidden="true" tabindex="-1"></a>    Json(items)</span>
+<span id="cb24-45"><a href="#cb24-45" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h2 id="références">Références</h2>
+<h3 id="exemples-dans-le-codebase">Exemples dans le codebase</h3>
+<table>
+<colgroup>
+<col style="width: 28%" />
+<col style="width: 36%" />
+<col style="width: 36%" />
+</colgroup>
+<thead>
+<tr>
+<th>Crate</th>
+<th>Fichier</th>
+<th>Pattern</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>pmoparadise</code></td>
+<td><code>src/pmoserver_ext.rs:367-392</code></td>
+<td>Extension simple avec OpenAPI</td>
+</tr>
+<tr>
+<td><code>pmoaudiocache</code></td>
+<td><code>src/lib.rs:225-260</code></td>
+<td>Extension avec cache et fichiers</td>
+</tr>
+<tr>
+<td><code>pmomediaserver</code></td>
+<td><code>src/paradise_streaming.rs:70-148</code></td>
+<td>Extension avec routes dynamiques</td>
+</tr>
+<tr>
+<td><code>pmocontrol</code></td>
+<td><code>src/pmoserver_ext.rs:68-92</code></td>
+<td>Handlers avec <code>spawn_blocking</code></td>
+</tr>
+<tr>
+<td><code>pmoapp</code></td>
+<td><code>src/lib.rs:145-165</code></td>
+<td>Extension SPA avec RustEmbed</td>
+</tr>
+</tbody>
+</table>
+<h3 id="dépendances-communes">Dépendances communes</h3>
+<ul>
+<li><code>axum</code> : Framework HTTP (Router, handlers,
+extracteurs)</li>
+<li><code>async-trait</code> : Support des traits async</li>
+<li><code>tokio</code> : Runtime async (spawn, spawn_blocking,
+timeout)</li>
+<li><code>anyhow</code> : Gestion d’erreurs pour init</li>
+<li><code>tracing</code> : Logging structuré</li>
+<li><code>utoipa</code> : Documentation OpenAPI/Swagger</li>
+<li><code>serde</code> : Sérialisation JSON</li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/Done_WeabApp_debouncingSSE.html

@@ -0,0 +1,209 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>WeabApp_debouncingSSE</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1 id="rapport-suppression-de-la-logique-de-débouncing-sse">Rapport :
+Suppression de la logique de débouncing SSE</h1>
+<p><strong>Date</strong>: 2026-01-12 <strong>Tâche</strong>:
+WeabApp_debouncingSSE.md</p>
+<h2 id="objectif">Objectif</h2>
+<p>Supprimer la logique de débouncing inutile sur le canal SSE de
+l’application web PMOControl, puisque le serveur contrôle déjà le flux
+des événements.</p>
+<h2 id="analyse-préalable">Analyse préalable</h2>
+<p>J’ai identifié trois endroits avec des mécanismes de temporisation
+dans l’application web :</p>
+<h3 id="mediabrowser.vue---débouncing-sse-à-supprimer">1.
+MediaBrowser.vue - Débouncing SSE (À SUPPRIMER ✓)</h3>
+<ul>
+<li><strong>Débouncing</strong>: 200ms après invalidation du cache</li>
+<li><strong>Cooldown</strong>: 2 secondes entre les rechargements</li>
+<li><strong>Justification originale</strong>: “dédupliquer les
+événements SSE dans le même batch (polling 500ms)”</li>
+<li><strong>Problème</strong>: Cette logique est redondante puisque le
+serveur contrôle déjà le flux SSE</li>
+</ul>
+<h3 id="userenderers.ts---smart-fetching-à-conserver">2. useRenderers.ts
+- Smart fetching (À CONSERVER ✓)</h3>
+<ul>
+<li><strong>Mécanisme</strong>: Comparaison des timestamps
+<code>lastEventAt</code> vs <code>lastSnapshotAt</code></li>
+<li><strong>But</strong>: Éviter de refetch un snapshot déjà à jour</li>
+<li><strong>Justification</strong>: Ce n’est PAS du débouncing, c’est
+une optimisation intelligente qui évite des appels API inutiles</li>
+</ul>
+<h3 id="volumecontrol.vue---ui-debouncing-à-conserver">3.
+VolumeControl.vue - UI debouncing (À CONSERVER ✓)</h3>
+<ul>
+<li><strong>Débouncing</strong>: 300ms sur les changements de
+volume</li>
+<li><strong>But</strong>: Réduire les appels API pendant que
+l’utilisateur fait glisser le curseur</li>
+<li><strong>Justification</strong>: Débouncing légitime pour l’interface
+utilisateur</li>
+</ul>
+<h2 id="modifications-effectuées">Modifications effectuées</h2>
+<h3
+id="fichier-modifié-pmoappwebappsrccomponentspmocontrolmediabrowser.vue">Fichier
+modifié:
+<code>pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue</code></h3>
+<h4 id="suppression-des-variables-de-débouncing-ligne-27">1. Suppression
+des variables de débouncing (ligne ~27)</h4>
+<p><strong>Avant</strong>:</p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Flags pour gérer le rechargement automatique avec debounce et cooldown</span></span>
+<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> isRefreshing <span class="op">=</span> <span class="fu">ref</span>(<span class="kw">false</span>)<span class="op">;</span></span>
+<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> refreshTimeoutId <span class="op">=</span> <span class="fu">ref</span><span class="op">&lt;</span><span class="dt">number</span> <span class="op">|</span> <span class="dt">null</span><span class="op">&gt;</span>(<span class="kw">null</span>)<span class="op">;</span></span>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> lastRefreshTime <span class="op">=</span> <span class="fu">ref</span><span class="op">&lt;</span><span class="dt">number</span><span class="op">&gt;</span>(<span class="dv">0</span>)<span class="op">;</span></span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> REFRESH_COOLDOWN_MS <span class="op">=</span> <span class="dv">2000</span><span class="op">;</span> <span class="co">// Ne pas recharger plus d&#39;une fois toutes les 2 secondes</span></span></pre></div>
+<p><strong>Après</strong>:</p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Flag pour gérer le rechargement automatique</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> isRefreshing <span class="op">=</span> <span class="fu">ref</span>(<span class="kw">false</span>)<span class="op">;</span></span></pre></div>
+<h4 id="simplification-du-watcher-de-cache-ligne-53">2. Simplification
+du watcher de cache (ligne ~53)</h4>
+<p><strong>Avant</strong>:</p>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)</span></span>
+<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="co">// Cela se produit notamment quand on clique sur &quot;Lire maintenant&quot; sur une playlist,</span></span>
+<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a><span class="co">// ce qui déclenche un événement ContainersUpdated qui invalide le cache</span></span>
+<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a><span class="co">// Utilise un debounce de 3 secondes pour regrouper les multiples invalidations</span></span>
+<span id="cb3-5"><a href="#cb3-5" aria-hidden="true" tabindex="-1"></a><span class="co">// et un cooldown de 5 secondes pour éviter les rechargements successifs</span></span>
+<span id="cb3-6"><a href="#cb3-6" aria-hidden="true" tabindex="-1"></a><span class="fu">watch</span>(</span>
+<span id="cb3-7"><a href="#cb3-7" aria-hidden="true" tabindex="-1"></a>    () <span class="kw">=&gt;</span> browseData<span class="op">.</span><span class="at">value</span><span class="op">,</span></span>
+<span id="cb3-8"><a href="#cb3-8" aria-hidden="true" tabindex="-1"></a>    (data) <span class="kw">=&gt;</span> {</span>
+<span id="cb3-9"><a href="#cb3-9" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> (<span class="op">!</span>data <span class="op">&amp;&amp;</span> props<span class="op">.</span><span class="at">containerId</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>loading<span class="op">.</span><span class="at">value</span>) {</span>
+<span id="cb3-10"><a href="#cb3-10" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Vérifier le cooldown: ignorer si on a rechargé il y a moins de 5 secondes</span></span>
+<span id="cb3-11"><a href="#cb3-11" aria-hidden="true" tabindex="-1"></a>            <span class="kw">const</span> timeSinceLastRefresh <span class="op">=</span> <span class="bu">Date</span><span class="op">.</span><span class="fu">now</span>() <span class="op">-</span> lastRefreshTime<span class="op">.</span><span class="at">value</span><span class="op">;</span></span>
+<span id="cb3-12"><a href="#cb3-12" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> (timeSinceLastRefresh <span class="op">&lt;</span> REFRESH_COOLDOWN_MS) {</span>
+<span id="cb3-13"><a href="#cb3-13" aria-hidden="true" tabindex="-1"></a>                <span class="bu">console</span><span class="op">.</span><span class="fu">log</span>(</span>
+<span id="cb3-14"><a href="#cb3-14" aria-hidden="true" tabindex="-1"></a>                    <span class="vs">`[MediaBrowser] Cache invalidé mais cooldown actif (</span><span class="sc">${</span><span class="bu">Math</span><span class="op">.</span><span class="fu">round</span>((REFRESH_COOLDOWN_MS <span class="op">-</span> timeSinceLastRefresh) <span class="op">/</span> <span class="dv">1000</span>)<span class="sc">}</span><span class="vs">s restantes), rechargement ignoré`</span><span class="op">,</span></span>
+<span id="cb3-15"><a href="#cb3-15" aria-hidden="true" tabindex="-1"></a>                )<span class="op">;</span></span>
+<span id="cb3-16"><a href="#cb3-16" aria-hidden="true" tabindex="-1"></a>                <span class="cf">return</span><span class="op">;</span></span>
+<span id="cb3-17"><a href="#cb3-17" aria-hidden="true" tabindex="-1"></a>            }</span>
+<span id="cb3-18"><a href="#cb3-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-19"><a href="#cb3-19" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Annuler tout timeout en cours</span></span>
+<span id="cb3-20"><a href="#cb3-20" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> (refreshTimeoutId<span class="op">.</span><span class="at">value</span> <span class="op">!==</span> <span class="kw">null</span>) {</span>
+<span id="cb3-21"><a href="#cb3-21" aria-hidden="true" tabindex="-1"></a>                <span class="pp">clearTimeout</span>(refreshTimeoutId<span class="op">.</span><span class="at">value</span>)<span class="op">;</span></span>
+<span id="cb3-22"><a href="#cb3-22" aria-hidden="true" tabindex="-1"></a>            }</span>
+<span id="cb3-23"><a href="#cb3-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-24"><a href="#cb3-24" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Planifier le rechargement après 200ms</span></span>
+<span id="cb3-25"><a href="#cb3-25" aria-hidden="true" tabindex="-1"></a>            refreshTimeoutId<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="bu">window</span><span class="op">.</span><span class="fu">setTimeout</span>(<span class="kw">async</span> () <span class="kw">=&gt;</span> {</span>
+<span id="cb3-26"><a href="#cb3-26" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> (<span class="op">!</span>isRefreshing<span class="op">.</span><span class="at">value</span>) {</span>
+<span id="cb3-27"><a href="#cb3-27" aria-hidden="true" tabindex="-1"></a>                    <span class="bu">console</span><span class="op">.</span><span class="fu">log</span>(</span>
+<span id="cb3-28"><a href="#cb3-28" aria-hidden="true" tabindex="-1"></a>                        <span class="vs">`[MediaBrowser] Cache invalidé pour </span><span class="sc">${</span>props<span class="op">.</span><span class="at">serverId</span><span class="sc">}</span><span class="vs">/</span><span class="sc">${</span>props<span class="op">.</span><span class="at">containerId</span><span class="sc">}</span><span class="vs">, rechargement après debounce...`</span><span class="op">,</span></span>
+<span id="cb3-29"><a href="#cb3-29" aria-hidden="true" tabindex="-1"></a>                    )<span class="op">;</span></span>
+<span id="cb3-30"><a href="#cb3-30" aria-hidden="true" tabindex="-1"></a>                    isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">true</span><span class="op">;</span></span>
+<span id="cb3-31"><a href="#cb3-31" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">await</span> <span class="fu">browseContainer</span>(</span>
+<span id="cb3-32"><a href="#cb3-32" aria-hidden="true" tabindex="-1"></a>                        props<span class="op">.</span><span class="at">serverId</span><span class="op">,</span></span>
+<span id="cb3-33"><a href="#cb3-33" aria-hidden="true" tabindex="-1"></a>                        props<span class="op">.</span><span class="at">containerId</span><span class="op">,</span></span>
+<span id="cb3-34"><a href="#cb3-34" aria-hidden="true" tabindex="-1"></a>                        <span class="kw">false</span><span class="op">,</span></span>
+<span id="cb3-35"><a href="#cb3-35" aria-hidden="true" tabindex="-1"></a>                    )<span class="op">;</span></span>
+<span id="cb3-36"><a href="#cb3-36" aria-hidden="true" tabindex="-1"></a>                    lastRefreshTime<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="bu">Date</span><span class="op">.</span><span class="fu">now</span>()<span class="op">;</span></span>
+<span id="cb3-37"><a href="#cb3-37" aria-hidden="true" tabindex="-1"></a>                    isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">false</span><span class="op">;</span></span>
+<span id="cb3-38"><a href="#cb3-38" aria-hidden="true" tabindex="-1"></a>                    refreshTimeoutId<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">null</span><span class="op">;</span></span>
+<span id="cb3-39"><a href="#cb3-39" aria-hidden="true" tabindex="-1"></a>                }</span>
+<span id="cb3-40"><a href="#cb3-40" aria-hidden="true" tabindex="-1"></a>            }<span class="op">,</span> <span class="dv">200</span>)<span class="op">;</span></span>
+<span id="cb3-41"><a href="#cb3-41" aria-hidden="true" tabindex="-1"></a>        }</span>
+<span id="cb3-42"><a href="#cb3-42" aria-hidden="true" tabindex="-1"></a>    }<span class="op">,</span></span>
+<span id="cb3-43"><a href="#cb3-43" aria-hidden="true" tabindex="-1"></a>)<span class="op">;</span></span></pre></div>
+<p><strong>Après</strong>:</p>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="co">// Cela se produit notamment quand on clique sur &quot;Lire maintenant&quot; sur une playlist,</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="co">// ce qui déclenche un événement ContainersUpdated qui invalide le cache</span></span>
+<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a><span class="co">// Le serveur contrôle déjà le flux SSE, pas besoin de debouncing côté client</span></span>
+<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a><span class="fu">watch</span>(</span>
+<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a>    () <span class="kw">=&gt;</span> browseData<span class="op">.</span><span class="at">value</span><span class="op">,</span></span>
+<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> (data) <span class="kw">=&gt;</span> {</span>
+<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Si browseData devient undefined alors que containerId est présent,</span></span>
+<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a>        <span class="co">// et qu&#39;on n&#39;est pas déjà en train de charger, recharger immédiatement</span></span>
+<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> (<span class="op">!</span>data <span class="op">&amp;&amp;</span> props<span class="op">.</span><span class="at">containerId</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>loading<span class="op">.</span><span class="at">value</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>isRefreshing<span class="op">.</span><span class="at">value</span>) {</span>
+<span id="cb4-11"><a href="#cb4-11" aria-hidden="true" tabindex="-1"></a>            <span class="bu">console</span><span class="op">.</span><span class="fu">log</span>(</span>
+<span id="cb4-12"><a href="#cb4-12" aria-hidden="true" tabindex="-1"></a>                <span class="vs">`[MediaBrowser] Cache invalidé pour </span><span class="sc">${</span>props<span class="op">.</span><span class="at">serverId</span><span class="sc">}</span><span class="vs">/</span><span class="sc">${</span>props<span class="op">.</span><span class="at">containerId</span><span class="sc">}</span><span class="vs">, rechargement...`</span><span class="op">,</span></span>
+<span id="cb4-13"><a href="#cb4-13" aria-hidden="true" tabindex="-1"></a>            )<span class="op">;</span></span>
+<span id="cb4-14"><a href="#cb4-14" aria-hidden="true" tabindex="-1"></a>            isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">true</span><span class="op">;</span></span>
+<span id="cb4-15"><a href="#cb4-15" aria-hidden="true" tabindex="-1"></a>            <span class="cf">await</span> <span class="fu">browseContainer</span>(props<span class="op">.</span><span class="at">serverId</span><span class="op">,</span> props<span class="op">.</span><span class="at">containerId</span><span class="op">,</span> <span class="kw">false</span>)<span class="op">;</span></span>
+<span id="cb4-16"><a href="#cb4-16" aria-hidden="true" tabindex="-1"></a>            isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">false</span><span class="op">;</span></span>
+<span id="cb4-17"><a href="#cb4-17" aria-hidden="true" tabindex="-1"></a>        }</span>
+<span id="cb4-18"><a href="#cb4-18" aria-hidden="true" tabindex="-1"></a>    }<span class="op">,</span></span>
+<span id="cb4-19"><a href="#cb4-19" aria-hidden="true" tabindex="-1"></a>)<span class="op">;</span></span></pre></div>
+<h2 id="résultats">Résultats</h2>
+<h3 id="changements-de-comportement">Changements de comportement</h3>
+<ul>
+<li><strong>Avant</strong>: Délai de 200ms + cooldown de 2s entre les
+rechargements de cache</li>
+<li><strong>Après</strong>: Rechargement immédiat dès l’invalidation du
+cache</li>
+<li><strong>Impact</strong>: Réactivité améliorée de l’interface, les
+mises à jour apparaissent immédiatement</li>
+</ul>
+<h3 id="réduction-de-complexité">Réduction de complexité</h3>
+<ul>
+<li><strong>3 variables supprimées</strong>:
+<code>refreshTimeoutId</code>, <code>lastRefreshTime</code>,
+<code>REFRESH_COOLDOWN_MS</code></li>
+<li><strong>Logique simplifiée</strong>: De ~40 lignes à ~10 lignes dans
+le watcher</li>
+<li><strong>Code plus lisible</strong>: Intention claire sans mécanismes
+de temporisation complexes</li>
+</ul>
+<h3 id="tests">Tests</h3>
+<ul>
+<li>✓ Le projet compile sans erreurs TypeScript</li>
+<li>✓ Le flag <code>isRefreshing</code> empêche toujours les
+rechargements concurrents</li>
+<li>✓ Les autres composants (useRenderers.ts, VolumeControl.vue)
+conservent leurs optimisations légitimes</li>
+</ul>
+<h2 id="conclusion">Conclusion</h2>
+<p>La suppression du débouncing et du cooldown dans MediaBrowser.vue
+simplifie le code tout en améliorant la réactivité de l’interface.
+Puisque le serveur contrôle déjà le flux SSE, ces mécanismes côté client
+étaient redondants et ajoutaient une latence artificielle.</p>
+<p>Le code est maintenant plus simple, plus réactif, et fait confiance
+au serveur pour contrôler la fréquence des événements SSE.</p>
+<h2 id="fichiers-modifiés">Fichiers modifiés</h2>
+<ul>
+<li><code>pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue</code></li>
+</ul>
+<h2 id="lignes-de-code">Lignes de code</h2>
+<ul>
+<li><strong>Supprimées</strong>: ~35 lignes (logique de
+débouncing/cooldown)</li>
+<li><strong>Ajoutées</strong>: ~5 lignes (logique simplifiée)</li>
+<li><strong>Net</strong>: -30 lignes</li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/Report_Pinnable_cache_item.html

@@ -0,0 +1,518 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Pinnable_cache_item</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1
+id="rapport-implémentation-des-items-épinglables-dans-pmocache">Rapport
+: Implémentation des items épinglables dans PMOcache</h1>
+<h2 id="résumé">Résumé</h2>
+<p>Implémentation réussie de la fonctionnalité d’items épinglables dans
+la crate PMOcache, permettant de protéger certains items de l’éviction
+automatique par la politique LRU. Cette fonctionnalité inclut également
+un système de TTL (Time To Live) avec une règle métier empêchant qu’un
+item soit à la fois épinglé et avec un TTL.</p>
+<h2 id="modifications-apportées">Modifications apportées</h2>
+<h3 id="structure-de-la-base-de-données-pmocachesrcdb.rs">1. Structure
+de la base de données (<code>pmocache/src/db.rs</code>)</h3>
+<h4 id="modification-du-schéma-de-la-table-asset">Modification du schéma
+de la table <code>asset</code></h4>
+<p>Ajout de deux nouvelles colonnes :</p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode sql"><code class="sourceCode sql"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">CREATE</span> <span class="kw">TABLE</span> <span class="cf">IF</span> <span class="kw">NOT</span> <span class="kw">EXISTS</span> asset (</span>
+<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a>    pk TEXT <span class="kw">PRIMARY</span> <span class="kw">KEY</span>,</span>
+<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a>    collection TEXT,</span>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">id</span> TEXT,</span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a>    hits <span class="dt">INTEGER</span> <span class="kw">DEFAULT</span> <span class="dv">0</span>,</span>
+<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a>    last_used TEXT,</span>
+<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a>    lazy_pk TEXT,</span>
+<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a>    pinned <span class="dt">INTEGER</span> <span class="kw">DEFAULT</span> <span class="dv">0</span> <span class="kw">CHECK</span> (pinned <span class="kw">IN</span> (<span class="dv">0</span>, <span class="dv">1</span>)),</span>
+<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a>    ttl_expires_at TEXT</span>
+<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a>)</span></pre></div>
+<ul>
+<li><strong><code>pinned</code></strong> : Booléen (0 ou 1) indiquant si
+l’item est épinglé</li>
+<li><strong><code>ttl_expires_at</code></strong> : Date/heure
+d’expiration au format RFC3339 (optionnel)</li>
+</ul>
+<h4 id="mise-à-jour-de-la-structure-cacheentry">Mise à jour de la
+structure <code>CacheEntry</code></h4>
+<p>Ajout des champs correspondants :</p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> CacheEntry <span class="op">{</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a>    <span class="co">// ... champs existants ...</span></span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> pinned<span class="op">:</span> <span class="dt">bool</span><span class="op">,</span></span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> ttl_expires_at<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a>    <span class="co">// ...</span></span>
+<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h4 id="nouvelles-méthodes-dans-db">Nouvelles méthodes dans
+<code>DB</code></h4>
+<h5 id="gestion-du-comptage">Gestion du comptage</h5>
+<ul>
+<li><strong><code>count_unpinned()</code></strong> : Compte uniquement
+les items non épinglés
+<ul>
+<li>Les items épinglés ne comptent pas dans la limite du cache</li>
+</ul></li>
+</ul>
+<h5 id="gestion-du-pinning">Gestion du pinning</h5>
+<ul>
+<li><p><strong><code>pin(pk: &amp;str)</code></strong> : Épingle un
+item</p>
+<ul>
+<li>Vérifie que l’item n’a pas de TTL défini (règle métier)</li>
+<li>Retourne une erreur si le TTL est déjà défini</li>
+</ul></li>
+<li><p><strong><code>unpin(pk: &amp;str)</code></strong> : Désépingle un
+item</p></li>
+<li><p><strong><code>is_pinned(pk: &amp;str)</code></strong> : Vérifie
+si un item est épinglé</p></li>
+</ul>
+<h5 id="gestion-du-ttl">Gestion du TTL</h5>
+<ul>
+<li><p><strong><code>set_ttl(pk: &amp;str, expires_at: &amp;str)</code></strong>
+: Définit le TTL d’un item</p>
+<ul>
+<li>Vérifie que l’item n’est pas épinglé (règle métier)</li>
+<li>Retourne une erreur si l’item est épinglé</li>
+</ul></li>
+<li><p><strong><code>clear_ttl(pk: &amp;str)</code></strong> : Supprime
+le TTL d’un item</p></li>
+<li><p><strong><code>get_expired()</code></strong> : Récupère tous les
+items dont le TTL est dépassé</p></li>
+</ul>
+<h5 id="modification-de-get_oldest">Modification de
+<code>get_oldest()</code></h5>
+<p>La requête SQL exclut maintenant les items épinglés :</p>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode sql"><code class="sourceCode sql"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">SELECT</span> <span class="op">..</span>. <span class="kw">FROM</span> asset</span>
+<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="kw">WHERE</span> pinned <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a><span class="kw">ORDER</span> <span class="kw">BY</span> last_used <span class="kw">ASC</span>, hits <span class="kw">ASC</span></span>
+<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a><span class="kw">LIMIT</span> ?<span class="dv">1</span></span></pre></div>
+<h3 id="logique-du-cache-pmocachesrccache.rs">2. Logique du cache
+(<code>pmocache/src/cache.rs</code>)</h3>
+<h4 id="méthodes-publiques-ajoutées">Méthodes publiques ajoutées</h4>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">async</span> <span class="kw">fn</span> pin(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> pk<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">async</span> <span class="kw">fn</span> unpin(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> pk<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">async</span> <span class="kw">fn</span> is_pinned(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> pk<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span></span>
+<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">async</span> <span class="kw">fn</span> set_ttl(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> pk<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span><span class="op">,</span> expires_at<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span></span>
+<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">async</span> <span class="kw">fn</span> clear_ttl(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> pk<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span></span></pre></div>
+<h4 id="modification-de-enforce_limit">Modification de
+<code>enforce_limit()</code></h4>
+<p>La politique d’éviction a été améliorée :</p>
+<ol type="1">
+<li><strong>Suppression prioritaire des items expirés</strong> : Les
+items dont le TTL est dépassé sont supprimés en premier</li>
+<li><strong>Comptage des items non épinglés</strong> : Utilise
+<code>count_unpinned()</code> au lieu de <code>count()</code></li>
+<li><strong>Protection des items épinglés</strong> : Ils ne peuvent pas
+être évincés par LRU</li>
+<li><strong>Logging amélioré</strong> : Messages distincts pour les
+items expirés et l’éviction LRU</li>
+</ol>
+<h3 id="tests-pmocacheteststest_pinnable.rs">3. Tests
+(<code>pmocache/tests/test_pinnable.rs</code>)</h3>
+<p>Création d’une suite complète de tests (9 tests, tous passants) :</p>
+<ol type="1">
+<li><strong><code>test_pin_unpin</code></strong> : Vérifie l’épinglage
+et le désépinglage basiques</li>
+<li><strong><code>test_pinned_excluded_from_lru</code></strong> :
+Vérifie que les items épinglés ne sont pas évincés</li>
+<li><strong><code>test_pinned_count_separately</code></strong> : Vérifie
+le comptage séparé des items épinglés</li>
+<li><strong><code>test_cannot_pin_with_ttl</code></strong> : Vérifie la
+règle métier TTL → pas de pinning</li>
+<li><strong><code>test_cannot_set_ttl_when_pinned</code></strong> :
+Vérifie la règle métier pinned → pas de TTL</li>
+<li><strong><code>test_ttl_expiration</code></strong> : Vérifie la
+suppression automatique des items expirés</li>
+<li><strong><code>test_clear_ttl</code></strong> : Vérifie la
+suppression du TTL</li>
+<li><strong><code>test_get_expired</code></strong> : Vérifie la
+récupération des items expirés</li>
+<li><strong><code>test_cache_entry_fields</code></strong> : Vérifie les
+valeurs des champs dans <code>CacheEntry</code></li>
+</ol>
+<h2 id="règles-métier-implémentées">Règles métier implémentées</h2>
+<h3 id="incompatibilité-ttl-pinned">Incompatibilité TTL ↔︎ Pinned</h3>
+<p>Un item ne peut pas être à la fois épinglé ET avoir un TTL :</p>
+<ul>
+<li><strong>Si TTL défini</strong> : <code>pin()</code> retourne une
+erreur</li>
+<li><strong>Si épinglé</strong> : <code>set_ttl()</code> retourne une
+erreur</li>
+</ul>
+<p>Cette règle garantit une sémantique claire : -
+<strong>Épinglé</strong> = permanent, protégé de l’éviction -
+<strong>TTL</strong> = temporaire, sera supprimé à expiration</p>
+<h3 id="comptage-des-items">Comptage des items</h3>
+<p>Les items épinglés sont <strong>exclus</strong> du comptage de la
+limite du cache :</p>
+<ul>
+<li>Un cache de limite 100 peut contenir 100 items non épinglés + N
+items épinglés</li>
+<li>Seuls les items non épinglés sont pris en compte pour l’éviction
+LRU</li>
+</ul>
+<h3 id="ordre-de-suppression-lors-de-enforce_limit">Ordre de suppression
+lors de <code>enforce_limit()</code></h3>
+<ol type="1">
+<li><strong>Items expirés (TTL dépassé)</strong> : supprimés en
+priorité</li>
+<li><strong>Items LRU</strong> : si la limite est toujours dépassée,
+suppression des plus vieux items <strong>non épinglés</strong></li>
+</ol>
+<h2 id="compatibilité">Compatibilité</h2>
+<h3 id="migration-de-base-de-données">Migration de base de données</h3>
+<p><strong>Aucune migration nécessaire</strong> : Les colonnes
+<code>pinned</code> et <code>ttl_expires_at</code> ont des valeurs par
+défaut : - <code>pinned = 0</code> (non épinglé) -
+<code>ttl_expires_at = NULL</code> (pas de TTL)</p>
+<p>Les bases existantes seront automatiquement mises à jour au prochain
+démarrage via le <code>CREATE TABLE IF NOT EXISTS</code> avec les
+nouvelles colonnes.</p>
+<h3 id="rétrocompatibilité-du-code">Rétrocompatibilité du code</h3>
+<p>Toutes les méthodes existantes continuent de fonctionner sans
+modification : - Les items existants ne sont pas épinglés par défaut -
+Le comportement LRU standard reste identique pour les items non
+épinglés</p>
+<h2 id="exemples-dutilisation">Exemples d’utilisation</h2>
+<h3 id="utilisation-programmatique-rust">Utilisation programmatique
+(Rust)</h3>
+<div class="sourceCode" id="cb5"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmocache::</span><span class="op">{</span>Cache<span class="op">,</span> CacheConfig<span class="op">};</span></span>
+<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">chrono::</span><span class="op">{</span>Duration<span class="op">,</span> Utc<span class="op">};</span></span>
+<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a><span class="co">// Créer un cache</span></span>
+<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> cache <span class="op">=</span> <span class="pp">Cache::</span><span class="op">&lt;</span>MyConfig<span class="op">&gt;</span><span class="pp">::</span>new(<span class="st">&quot;./cache&quot;</span><span class="op">,</span> <span class="dv">100</span>)<span class="op">.</span>unwrap()<span class="op">;</span></span>
+<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a><span class="co">// Ajouter un fichier</span></span>
+<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> pk <span class="op">=</span> cache<span class="op">.</span>add_from_url(<span class="st">&quot;https://example.com/file.dat&quot;</span><span class="op">,</span> <span class="cn">None</span>)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a><span class="co">// Épingler pour protéger de l&#39;éviction</span></span>
+<span id="cb5-11"><a href="#cb5-11" aria-hidden="true" tabindex="-1"></a>cache<span class="op">.</span>pin(<span class="op">&amp;</span>pk)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb5-12"><a href="#cb5-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-13"><a href="#cb5-13" aria-hidden="true" tabindex="-1"></a><span class="co">// Ou définir un TTL de 24 heures</span></span>
+<span id="cb5-14"><a href="#cb5-14" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> expires_at <span class="op">=</span> (<span class="pp">Utc::</span>now() <span class="op">+</span> <span class="pp">Duration::</span>hours(<span class="dv">24</span>))<span class="op">.</span>to_rfc3339()<span class="op">;</span></span>
+<span id="cb5-15"><a href="#cb5-15" aria-hidden="true" tabindex="-1"></a>cache<span class="op">.</span>set_ttl(<span class="op">&amp;</span>pk2<span class="op">,</span> <span class="op">&amp;</span>expires_at)<span class="op">.</span><span class="kw">await</span><span class="op">?;</span></span>
+<span id="cb5-16"><a href="#cb5-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-17"><a href="#cb5-17" aria-hidden="true" tabindex="-1"></a><span class="co">// Vérifier le statut</span></span>
+<span id="cb5-18"><a href="#cb5-18" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> cache<span class="op">.</span>is_pinned(<span class="op">&amp;</span>pk)<span class="op">.</span><span class="kw">await</span><span class="op">?</span> <span class="op">{</span></span>
+<span id="cb5-19"><a href="#cb5-19" aria-hidden="true" tabindex="-1"></a>    <span class="pp">println!</span>(<span class="st">&quot;Fichier protégé&quot;</span>)<span class="op">;</span></span>
+<span id="cb5-20"><a href="#cb5-20" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h3 id="utilisation-via-lapi-rest">Utilisation via l’API REST</h3>
+<h4 id="récupérer-le-statut-de-pinning">Récupérer le statut de
+pinning</h4>
+<div class="sourceCode" id="cb6"><pre
+class="sourceCode bash"><code class="sourceCode bash"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="ex">GET</span> /api/cache/{pk}/pin</span>
+<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 200 OK:</span>
+<span id="cb6-4"><a href="#cb6-4" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb6-5"><a href="#cb6-5" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;pk&quot;</span><span class="ex">:</span> <span class="st">&quot;1a2b3c4d5e6f7a8b&quot;</span>,</span>
+<span id="cb6-6"><a href="#cb6-6" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;pinned&quot;</span><span class="ex">:</span> false,</span>
+<span id="cb6-7"><a href="#cb6-7" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;ttl_expires_at&quot;</span><span class="ex">:</span> null</span>
+<span id="cb6-8"><a href="#cb6-8" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span></pre></div>
+<h4 id="épingler-un-item">Épingler un item</h4>
+<div class="sourceCode" id="cb7"><pre
+class="sourceCode bash"><code class="sourceCode bash"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="ex">POST</span> /api/cache/{pk}/pin</span>
+<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 200 OK:</span>
+<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;pk&quot;</span><span class="ex">:</span> <span class="st">&quot;1a2b3c4d5e6f7a8b&quot;</span>,</span>
+<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;Item &#39;1a2b3c4d5e6f7a8b&#39; pinned successfully&quot;</span></span>
+<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span>
+<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-9"><a href="#cb7-9" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 409 CONFLICT <span class="er">(</span><span class="ex">si</span> TTL défini<span class="kw">)</span><span class="bu">:</span></span>
+<span id="cb7-10"><a href="#cb7-10" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb7-11"><a href="#cb7-11" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;error&quot;</span><span class="ex">:</span> <span class="st">&quot;CONFLICT&quot;</span>,</span>
+<span id="cb7-12"><a href="#cb7-12" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;Cannot pin an item with TTL set. Clear TTL first.&quot;</span></span>
+<span id="cb7-13"><a href="#cb7-13" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span></pre></div>
+<h4 id="désépingler-un-item">Désépingler un item</h4>
+<div class="sourceCode" id="cb8"><pre
+class="sourceCode bash"><code class="sourceCode bash"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="ex">DELETE</span> /api/cache/{pk}/pin</span>
+<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 200 OK:</span>
+<span id="cb8-4"><a href="#cb8-4" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;pk&quot;</span><span class="ex">:</span> <span class="st">&quot;1a2b3c4d5e6f7a8b&quot;</span>,</span>
+<span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;Item &#39;1a2b3c4d5e6f7a8b&#39; unpinned successfully&quot;</span></span>
+<span id="cb8-7"><a href="#cb8-7" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span></pre></div>
+<h4 id="définir-un-ttl">Définir un TTL</h4>
+<div class="sourceCode" id="cb9"><pre
+class="sourceCode bash"><code class="sourceCode bash"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="ex">POST</span> /api/cache/{pk}/ttl</span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a><span class="ex">Content-Type:</span> application/json</span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb9-5"><a href="#cb9-5" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;expires_at&quot;</span><span class="ex">:</span> <span class="st">&quot;2025-01-20T10:30:00Z&quot;</span></span>
+<span id="cb9-6"><a href="#cb9-6" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span>
+<span id="cb9-7"><a href="#cb9-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-8"><a href="#cb9-8" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 200 OK:</span>
+<span id="cb9-9"><a href="#cb9-9" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb9-10"><a href="#cb9-10" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;pk&quot;</span><span class="ex">:</span> <span class="st">&quot;1a2b3c4d5e6f7a8b&quot;</span>,</span>
+<span id="cb9-11"><a href="#cb9-11" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;TTL set successfully for item &#39;1a2b3c4d5e6f7a8b&#39;&quot;</span></span>
+<span id="cb9-12"><a href="#cb9-12" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span>
+<span id="cb9-13"><a href="#cb9-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-14"><a href="#cb9-14" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 409 CONFLICT <span class="er">(</span><span class="ex">si</span> épinglé<span class="kw">)</span><span class="bu">:</span></span>
+<span id="cb9-15"><a href="#cb9-15" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb9-16"><a href="#cb9-16" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;error&quot;</span><span class="ex">:</span> <span class="st">&quot;CONFLICT&quot;</span>,</span>
+<span id="cb9-17"><a href="#cb9-17" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;Cannot set TTL on a pinned item. Unpin first.&quot;</span></span>
+<span id="cb9-18"><a href="#cb9-18" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span>
+<span id="cb9-19"><a href="#cb9-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-20"><a href="#cb9-20" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 400 BAD REQUEST <span class="er">(</span><span class="ex">format</span> invalide<span class="kw">)</span><span class="bu">:</span></span>
+<span id="cb9-21"><a href="#cb9-21" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb9-22"><a href="#cb9-22" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;error&quot;</span><span class="ex">:</span> <span class="st">&quot;INVALID_DATE&quot;</span>,</span>
+<span id="cb9-23"><a href="#cb9-23" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;Invalid RFC3339 date format&quot;</span></span>
+<span id="cb9-24"><a href="#cb9-24" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span></pre></div>
+<h4 id="supprimer-un-ttl">Supprimer un TTL</h4>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode bash"><code class="sourceCode bash"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="ex">DELETE</span> /api/cache/{pk}/ttl</span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Response</span> 200 OK:</span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="kw">{</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;pk&quot;</span><span class="ex">:</span> <span class="st">&quot;1a2b3c4d5e6f7a8b&quot;</span>,</span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a>  <span class="st">&quot;message&quot;</span><span class="ex">:</span> <span class="st">&quot;TTL cleared successfully for item &#39;1a2b3c4d5e6f7a8b&#39;&quot;</span></span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a><span class="kw">}</span></span></pre></div>
+<h2 id="fichiers-modifiés">Fichiers modifiés</h2>
+<h3 id="phase-1-implémentation-de-base">Phase 1 : Implémentation de
+base</h3>
+<ol type="1">
+<li><strong><code>pmocache/src/db.rs</code></strong> :
+<ul>
+<li>Modification du schéma SQL</li>
+<li>Ajout de champs dans <code>CacheEntry</code></li>
+<li>Ajout de 8 nouvelles méthodes</li>
+<li>Modification de <code>get_oldest()</code>, <code>get()</code>,
+<code>get_from_id()</code>, <code>get_all()</code>,
+<code>get_by_collection()</code></li>
+</ul></li>
+<li><strong><code>pmocache/src/cache.rs</code></strong> :
+<ul>
+<li>Ajout de 5 méthodes publiques</li>
+<li>Modification de <code>enforce_limit()</code></li>
+</ul></li>
+<li><strong><code>pmocache/tests/test_pinnable.rs</code></strong> :
+<ul>
+<li>Nouveau fichier de tests (9 tests)</li>
+</ul></li>
+</ol>
+<h3 id="phase-2-enrichissement-de-lapi-rest">Phase 2 : Enrichissement de
+l’API REST</h3>
+<ol start="4" type="1">
+<li><strong><code>pmocache/src/api.rs</code></strong> :
+<ul>
+<li>Ajout de 3 nouvelles structures de données :
+<code>SetTtlRequest</code>, <code>PinResponse</code>,
+<code>PinStatus</code></li>
+<li>Ajout de 5 nouveaux handlers d’API :
+<ul>
+<li><code>get_pin_status()</code> : Récupération du statut de
+pinning</li>
+<li><code>pin_item()</code> : Épinglage d’un item</li>
+<li><code>unpin_item()</code> : Désépinglage d’un item</li>
+<li><code>set_item_ttl()</code> : Définition du TTL</li>
+<li><code>clear_item_ttl()</code> : Suppression du TTL</li>
+</ul></li>
+</ul></li>
+<li><strong><code>pmocache/src/pmoserver_ext.rs</code></strong> :
+<ul>
+<li>Ajout de 4 nouvelles routes dans <code>create_api_router()</code> :
+<ul>
+<li><code>GET /{pk}/pin</code> : Statut de pinning</li>
+<li><code>POST /{pk}/pin</code> : Épingler</li>
+<li><code>DELETE /{pk}/pin</code> : Désépingler</li>
+<li><code>POST /{pk}/ttl</code> : Définir TTL</li>
+<li><code>DELETE /{pk}/ttl</code> : Supprimer TTL</li>
+</ul></li>
+</ul></li>
+<li><strong><code>pmocache/src/openapi.rs</code></strong> :
+<ul>
+<li>Mise à jour de la macro <code>create_cache_openapi!</code> pour
+inclure :
+<ul>
+<li>Les 5 nouveaux endpoints dans la documentation</li>
+<li>Les 3 nouvelles structures dans les schémas OpenAPI</li>
+</ul></li>
+</ul></li>
+<li><strong><code>pmocache/src/lib.rs</code></strong> :
+<ul>
+<li>Export des nouvelles structures publiques pour l’API</li>
+</ul></li>
+</ol>
+<h2 id="api-rest-et-documentation-openapi">API REST et Documentation
+OpenAPI</h2>
+<h3 id="routes-disponibles">Routes disponibles</h3>
+<p>Toutes les routes sont préfixées par <code>/api/{cache_name}/</code>
+(ex: <code>/api/covers/</code>, <code>/api/audio/</code>).</p>
+<table>
+<colgroup>
+<col style="width: 31%" />
+<col style="width: 24%" />
+<col style="width: 44%" />
+</colgroup>
+<thead>
+<tr>
+<th>Méthode</th>
+<th>Route</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>GET</code></td>
+<td><code>/{pk}/pin</code></td>
+<td>Récupère le statut de pinning d’un item</td>
+</tr>
+<tr>
+<td><code>POST</code></td>
+<td><code>/{pk}/pin</code></td>
+<td>Épingle un item (le protège de l’éviction LRU)</td>
+</tr>
+<tr>
+<td><code>DELETE</code></td>
+<td><code>/{pk}/pin</code></td>
+<td>Désépingle un item</td>
+</tr>
+<tr>
+<td><code>POST</code></td>
+<td><code>/{pk}/ttl</code></td>
+<td>Définit le TTL d’un item (expiration automatique)</td>
+</tr>
+<tr>
+<td><code>DELETE</code></td>
+<td><code>/{pk}/ttl</code></td>
+<td>Supprime le TTL d’un item</td>
+</tr>
+</tbody>
+</table>
+<h3 id="codes-de-statut-http">Codes de statut HTTP</h3>
+<table>
+<colgroup>
+<col style="width: 18%" />
+<col style="width: 42%" />
+<col style="width: 39%" />
+</colgroup>
+<thead>
+<tr>
+<th>Code</th>
+<th>Signification</th>
+<th>Cas d’usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>200 OK</code></td>
+<td>Opération réussie</td>
+<td>Tous les cas de succès</td>
+</tr>
+<tr>
+<td><code>400 BAD REQUEST</code></td>
+<td>Requête invalide</td>
+<td>Format de date TTL invalide</td>
+</tr>
+<tr>
+<td><code>404 NOT FOUND</code></td>
+<td>Item non trouvé</td>
+<td>PK inexistant dans le cache</td>
+</tr>
+<tr>
+<td><code>409 CONFLICT</code></td>
+<td>Conflit de règle métier</td>
+<td>Tentative de pin avec TTL ou vice-versa</td>
+</tr>
+<tr>
+<td><code>500 INTERNAL SERVER ERROR</code></td>
+<td>Erreur serveur</td>
+<td>Erreur de base de données</td>
+</tr>
+</tbody>
+</table>
+<h3 id="documentation-openapiswagger">Documentation OpenAPI/Swagger</h3>
+<p>La documentation OpenAPI est automatiquement générée et inclut :</p>
+<ul>
+<li><strong>Schémas de données</strong> :
+<ul>
+<li><code>PinStatus</code> : Statut de pinning (pinned,
+ttl_expires_at)</li>
+<li><code>PinResponse</code> : Réponse d’opération de pinning</li>
+<li><code>SetTtlRequest</code> : Requête de définition de TTL</li>
+<li><code>CacheEntry</code> : Mis à jour avec les champs
+<code>pinned</code> et <code>ttl_expires_at</code></li>
+</ul></li>
+<li><strong>Endpoints documentés</strong> :
+<ul>
+<li>Description détaillée de chaque route</li>
+<li>Exemples de requêtes et réponses</li>
+<li>Codes d’erreur possibles</li>
+</ul></li>
+<li><strong>Interface Swagger UI</strong> :
+<ul>
+<li>Accessible à <code>/swagger-ui/{cache_name}</code></li>
+<li>Permet de tester l’API directement depuis le navigateur</li>
+</ul></li>
+</ul>
+<h3 id="gestion-des-erreurs">Gestion des erreurs</h3>
+<p>L’API suit une structure d’erreur cohérente :</p>
+<div class="sourceCode" id="cb11"><pre
+class="sourceCode json"><code class="sourceCode json"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="fu">{</span></span>
+<span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;error&quot;</span><span class="fu">:</span> <span class="st">&quot;CODE_ERREUR&quot;</span><span class="fu">,</span></span>
+<span id="cb11-3"><a href="#cb11-3" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;message&quot;</span><span class="fu">:</span> <span class="st">&quot;Description lisible de l&#39;erreur&quot;</span></span>
+<span id="cb11-4"><a href="#cb11-4" aria-hidden="true" tabindex="-1"></a><span class="fu">}</span></span></pre></div>
+<p>Les règles métier sont appliquées strictement : - <strong>409
+CONFLICT</strong> si tentative de pin avec TTL défini - <strong>409
+CONFLICT</strong> si tentative de set TTL sur item épinglé - Messages
+d’erreur explicites guidant l’utilisateur</p>
+<h2 id="tests">Tests</h2>
+<ul>
+<li><strong>Suite de tests dédiée</strong> : 9 tests, tous passants</li>
+<li><strong>Tests existants</strong> : Tous les tests de
+<code>test_cache.rs</code> passent toujours</li>
+<li><strong>Couverture</strong> : Toutes les nouvelles fonctionnalités
+sont testées</li>
+<li><strong>Compilation</strong> : Aucune erreur, tous les modules
+compilent correctement</li>
+</ul>
+<h2 id="résultat">Résultat</h2>
+<p>✅ <strong>Implémentation complète et fonctionnelle</strong> des
+items épinglables avec TTL<br />
+✅ <strong>Règle métier</strong> TTL ↔︎ Pinned correctement
+implémentée<br />
+✅ <strong>Tests exhaustifs</strong> validant tous les cas d’usage<br />
+✅ <strong>Compatibilité</strong> avec les bases de données
+existantes<br />
+✅ <strong>Pas de régression</strong> sur les tests existants<br />
+✅ <strong>API REST complète</strong> avec 5 nouveaux endpoints<br />
+✅ <strong>Documentation OpenAPI</strong> automatiquement générée<br />
+✅ <strong>Gestion d’erreurs cohérente</strong> avec codes HTTP
+appropriés</p>
+</article>
+</body>
+</html>

Blackboard_HTML/Report_WeabApp_debouncingSSE.html

@@ -0,0 +1,209 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>WeabApp_debouncingSSE</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1 id="rapport-suppression-de-la-logique-de-débouncing-sse">Rapport :
+Suppression de la logique de débouncing SSE</h1>
+<p><strong>Date</strong>: 2026-01-12 <strong>Tâche</strong>:
+WeabApp_debouncingSSE.md</p>
+<h2 id="objectif">Objectif</h2>
+<p>Supprimer la logique de débouncing inutile sur le canal SSE de
+l’application web PMOControl, puisque le serveur contrôle déjà le flux
+des événements.</p>
+<h2 id="analyse-préalable">Analyse préalable</h2>
+<p>J’ai identifié trois endroits avec des mécanismes de temporisation
+dans l’application web :</p>
+<h3 id="mediabrowser.vue---débouncing-sse-à-supprimer">1.
+MediaBrowser.vue - Débouncing SSE (À SUPPRIMER ✓)</h3>
+<ul>
+<li><strong>Débouncing</strong>: 200ms après invalidation du cache</li>
+<li><strong>Cooldown</strong>: 2 secondes entre les rechargements</li>
+<li><strong>Justification originale</strong>: “dédupliquer les
+événements SSE dans le même batch (polling 500ms)”</li>
+<li><strong>Problème</strong>: Cette logique est redondante puisque le
+serveur contrôle déjà le flux SSE</li>
+</ul>
+<h3 id="userenderers.ts---smart-fetching-à-conserver">2. useRenderers.ts
+- Smart fetching (À CONSERVER ✓)</h3>
+<ul>
+<li><strong>Mécanisme</strong>: Comparaison des timestamps
+<code>lastEventAt</code> vs <code>lastSnapshotAt</code></li>
+<li><strong>But</strong>: Éviter de refetch un snapshot déjà à jour</li>
+<li><strong>Justification</strong>: Ce n’est PAS du débouncing, c’est
+une optimisation intelligente qui évite des appels API inutiles</li>
+</ul>
+<h3 id="volumecontrol.vue---ui-debouncing-à-conserver">3.
+VolumeControl.vue - UI debouncing (À CONSERVER ✓)</h3>
+<ul>
+<li><strong>Débouncing</strong>: 300ms sur les changements de
+volume</li>
+<li><strong>But</strong>: Réduire les appels API pendant que
+l’utilisateur fait glisser le curseur</li>
+<li><strong>Justification</strong>: Débouncing légitime pour l’interface
+utilisateur</li>
+</ul>
+<h2 id="modifications-effectuées">Modifications effectuées</h2>
+<h3
+id="fichier-modifié-pmoappwebappsrccomponentspmocontrolmediabrowser.vue">Fichier
+modifié:
+<code>pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue</code></h3>
+<h4 id="suppression-des-variables-de-débouncing-ligne-27">1. Suppression
+des variables de débouncing (ligne ~27)</h4>
+<p><strong>Avant</strong>:</p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Flags pour gérer le rechargement automatique avec debounce et cooldown</span></span>
+<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> isRefreshing <span class="op">=</span> <span class="fu">ref</span>(<span class="kw">false</span>)<span class="op">;</span></span>
+<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> refreshTimeoutId <span class="op">=</span> <span class="fu">ref</span><span class="op">&lt;</span><span class="dt">number</span> <span class="op">|</span> <span class="dt">null</span><span class="op">&gt;</span>(<span class="kw">null</span>)<span class="op">;</span></span>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> lastRefreshTime <span class="op">=</span> <span class="fu">ref</span><span class="op">&lt;</span><span class="dt">number</span><span class="op">&gt;</span>(<span class="dv">0</span>)<span class="op">;</span></span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> REFRESH_COOLDOWN_MS <span class="op">=</span> <span class="dv">2000</span><span class="op">;</span> <span class="co">// Ne pas recharger plus d&#39;une fois toutes les 2 secondes</span></span></pre></div>
+<p><strong>Après</strong>:</p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Flag pour gérer le rechargement automatique</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> isRefreshing <span class="op">=</span> <span class="fu">ref</span>(<span class="kw">false</span>)<span class="op">;</span></span></pre></div>
+<h4 id="simplification-du-watcher-de-cache-ligne-53">2. Simplification
+du watcher de cache (ligne ~53)</h4>
+<p><strong>Avant</strong>:</p>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)</span></span>
+<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="co">// Cela se produit notamment quand on clique sur &quot;Lire maintenant&quot; sur une playlist,</span></span>
+<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a><span class="co">// ce qui déclenche un événement ContainersUpdated qui invalide le cache</span></span>
+<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a><span class="co">// Utilise un debounce de 3 secondes pour regrouper les multiples invalidations</span></span>
+<span id="cb3-5"><a href="#cb3-5" aria-hidden="true" tabindex="-1"></a><span class="co">// et un cooldown de 5 secondes pour éviter les rechargements successifs</span></span>
+<span id="cb3-6"><a href="#cb3-6" aria-hidden="true" tabindex="-1"></a><span class="fu">watch</span>(</span>
+<span id="cb3-7"><a href="#cb3-7" aria-hidden="true" tabindex="-1"></a>    () <span class="kw">=&gt;</span> browseData<span class="op">.</span><span class="at">value</span><span class="op">,</span></span>
+<span id="cb3-8"><a href="#cb3-8" aria-hidden="true" tabindex="-1"></a>    (data) <span class="kw">=&gt;</span> {</span>
+<span id="cb3-9"><a href="#cb3-9" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> (<span class="op">!</span>data <span class="op">&amp;&amp;</span> props<span class="op">.</span><span class="at">containerId</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>loading<span class="op">.</span><span class="at">value</span>) {</span>
+<span id="cb3-10"><a href="#cb3-10" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Vérifier le cooldown: ignorer si on a rechargé il y a moins de 5 secondes</span></span>
+<span id="cb3-11"><a href="#cb3-11" aria-hidden="true" tabindex="-1"></a>            <span class="kw">const</span> timeSinceLastRefresh <span class="op">=</span> <span class="bu">Date</span><span class="op">.</span><span class="fu">now</span>() <span class="op">-</span> lastRefreshTime<span class="op">.</span><span class="at">value</span><span class="op">;</span></span>
+<span id="cb3-12"><a href="#cb3-12" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> (timeSinceLastRefresh <span class="op">&lt;</span> REFRESH_COOLDOWN_MS) {</span>
+<span id="cb3-13"><a href="#cb3-13" aria-hidden="true" tabindex="-1"></a>                <span class="bu">console</span><span class="op">.</span><span class="fu">log</span>(</span>
+<span id="cb3-14"><a href="#cb3-14" aria-hidden="true" tabindex="-1"></a>                    <span class="vs">`[MediaBrowser] Cache invalidé mais cooldown actif (</span><span class="sc">${</span><span class="bu">Math</span><span class="op">.</span><span class="fu">round</span>((REFRESH_COOLDOWN_MS <span class="op">-</span> timeSinceLastRefresh) <span class="op">/</span> <span class="dv">1000</span>)<span class="sc">}</span><span class="vs">s restantes), rechargement ignoré`</span><span class="op">,</span></span>
+<span id="cb3-15"><a href="#cb3-15" aria-hidden="true" tabindex="-1"></a>                )<span class="op">;</span></span>
+<span id="cb3-16"><a href="#cb3-16" aria-hidden="true" tabindex="-1"></a>                <span class="cf">return</span><span class="op">;</span></span>
+<span id="cb3-17"><a href="#cb3-17" aria-hidden="true" tabindex="-1"></a>            }</span>
+<span id="cb3-18"><a href="#cb3-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-19"><a href="#cb3-19" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Annuler tout timeout en cours</span></span>
+<span id="cb3-20"><a href="#cb3-20" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> (refreshTimeoutId<span class="op">.</span><span class="at">value</span> <span class="op">!==</span> <span class="kw">null</span>) {</span>
+<span id="cb3-21"><a href="#cb3-21" aria-hidden="true" tabindex="-1"></a>                <span class="pp">clearTimeout</span>(refreshTimeoutId<span class="op">.</span><span class="at">value</span>)<span class="op">;</span></span>
+<span id="cb3-22"><a href="#cb3-22" aria-hidden="true" tabindex="-1"></a>            }</span>
+<span id="cb3-23"><a href="#cb3-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb3-24"><a href="#cb3-24" aria-hidden="true" tabindex="-1"></a>            <span class="co">// Planifier le rechargement après 200ms</span></span>
+<span id="cb3-25"><a href="#cb3-25" aria-hidden="true" tabindex="-1"></a>            refreshTimeoutId<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="bu">window</span><span class="op">.</span><span class="fu">setTimeout</span>(<span class="kw">async</span> () <span class="kw">=&gt;</span> {</span>
+<span id="cb3-26"><a href="#cb3-26" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> (<span class="op">!</span>isRefreshing<span class="op">.</span><span class="at">value</span>) {</span>
+<span id="cb3-27"><a href="#cb3-27" aria-hidden="true" tabindex="-1"></a>                    <span class="bu">console</span><span class="op">.</span><span class="fu">log</span>(</span>
+<span id="cb3-28"><a href="#cb3-28" aria-hidden="true" tabindex="-1"></a>                        <span class="vs">`[MediaBrowser] Cache invalidé pour </span><span class="sc">${</span>props<span class="op">.</span><span class="at">serverId</span><span class="sc">}</span><span class="vs">/</span><span class="sc">${</span>props<span class="op">.</span><span class="at">containerId</span><span class="sc">}</span><span class="vs">, rechargement après debounce...`</span><span class="op">,</span></span>
+<span id="cb3-29"><a href="#cb3-29" aria-hidden="true" tabindex="-1"></a>                    )<span class="op">;</span></span>
+<span id="cb3-30"><a href="#cb3-30" aria-hidden="true" tabindex="-1"></a>                    isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">true</span><span class="op">;</span></span>
+<span id="cb3-31"><a href="#cb3-31" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">await</span> <span class="fu">browseContainer</span>(</span>
+<span id="cb3-32"><a href="#cb3-32" aria-hidden="true" tabindex="-1"></a>                        props<span class="op">.</span><span class="at">serverId</span><span class="op">,</span></span>
+<span id="cb3-33"><a href="#cb3-33" aria-hidden="true" tabindex="-1"></a>                        props<span class="op">.</span><span class="at">containerId</span><span class="op">,</span></span>
+<span id="cb3-34"><a href="#cb3-34" aria-hidden="true" tabindex="-1"></a>                        <span class="kw">false</span><span class="op">,</span></span>
+<span id="cb3-35"><a href="#cb3-35" aria-hidden="true" tabindex="-1"></a>                    )<span class="op">;</span></span>
+<span id="cb3-36"><a href="#cb3-36" aria-hidden="true" tabindex="-1"></a>                    lastRefreshTime<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="bu">Date</span><span class="op">.</span><span class="fu">now</span>()<span class="op">;</span></span>
+<span id="cb3-37"><a href="#cb3-37" aria-hidden="true" tabindex="-1"></a>                    isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">false</span><span class="op">;</span></span>
+<span id="cb3-38"><a href="#cb3-38" aria-hidden="true" tabindex="-1"></a>                    refreshTimeoutId<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">null</span><span class="op">;</span></span>
+<span id="cb3-39"><a href="#cb3-39" aria-hidden="true" tabindex="-1"></a>                }</span>
+<span id="cb3-40"><a href="#cb3-40" aria-hidden="true" tabindex="-1"></a>            }<span class="op">,</span> <span class="dv">200</span>)<span class="op">;</span></span>
+<span id="cb3-41"><a href="#cb3-41" aria-hidden="true" tabindex="-1"></a>        }</span>
+<span id="cb3-42"><a href="#cb3-42" aria-hidden="true" tabindex="-1"></a>    }<span class="op">,</span></span>
+<span id="cb3-43"><a href="#cb3-43" aria-hidden="true" tabindex="-1"></a>)<span class="op">;</span></span></pre></div>
+<p><strong>Après</strong>:</p>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode typescript"><code class="sourceCode typescript"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="co">// Recharger automatiquement si le cache est invalidé (ex: après un ContainersUpdated SSE)</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="co">// Cela se produit notamment quand on clique sur &quot;Lire maintenant&quot; sur une playlist,</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="co">// ce qui déclenche un événement ContainersUpdated qui invalide le cache</span></span>
+<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a><span class="co">// Le serveur contrôle déjà le flux SSE, pas besoin de debouncing côté client</span></span>
+<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a><span class="fu">watch</span>(</span>
+<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a>    () <span class="kw">=&gt;</span> browseData<span class="op">.</span><span class="at">value</span><span class="op">,</span></span>
+<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">async</span> (data) <span class="kw">=&gt;</span> {</span>
+<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Si browseData devient undefined alors que containerId est présent,</span></span>
+<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a>        <span class="co">// et qu&#39;on n&#39;est pas déjà en train de charger, recharger immédiatement</span></span>
+<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> (<span class="op">!</span>data <span class="op">&amp;&amp;</span> props<span class="op">.</span><span class="at">containerId</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>loading<span class="op">.</span><span class="at">value</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>isRefreshing<span class="op">.</span><span class="at">value</span>) {</span>
+<span id="cb4-11"><a href="#cb4-11" aria-hidden="true" tabindex="-1"></a>            <span class="bu">console</span><span class="op">.</span><span class="fu">log</span>(</span>
+<span id="cb4-12"><a href="#cb4-12" aria-hidden="true" tabindex="-1"></a>                <span class="vs">`[MediaBrowser] Cache invalidé pour </span><span class="sc">${</span>props<span class="op">.</span><span class="at">serverId</span><span class="sc">}</span><span class="vs">/</span><span class="sc">${</span>props<span class="op">.</span><span class="at">containerId</span><span class="sc">}</span><span class="vs">, rechargement...`</span><span class="op">,</span></span>
+<span id="cb4-13"><a href="#cb4-13" aria-hidden="true" tabindex="-1"></a>            )<span class="op">;</span></span>
+<span id="cb4-14"><a href="#cb4-14" aria-hidden="true" tabindex="-1"></a>            isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">true</span><span class="op">;</span></span>
+<span id="cb4-15"><a href="#cb4-15" aria-hidden="true" tabindex="-1"></a>            <span class="cf">await</span> <span class="fu">browseContainer</span>(props<span class="op">.</span><span class="at">serverId</span><span class="op">,</span> props<span class="op">.</span><span class="at">containerId</span><span class="op">,</span> <span class="kw">false</span>)<span class="op">;</span></span>
+<span id="cb4-16"><a href="#cb4-16" aria-hidden="true" tabindex="-1"></a>            isRefreshing<span class="op">.</span><span class="at">value</span> <span class="op">=</span> <span class="kw">false</span><span class="op">;</span></span>
+<span id="cb4-17"><a href="#cb4-17" aria-hidden="true" tabindex="-1"></a>        }</span>
+<span id="cb4-18"><a href="#cb4-18" aria-hidden="true" tabindex="-1"></a>    }<span class="op">,</span></span>
+<span id="cb4-19"><a href="#cb4-19" aria-hidden="true" tabindex="-1"></a>)<span class="op">;</span></span></pre></div>
+<h2 id="résultats">Résultats</h2>
+<h3 id="changements-de-comportement">Changements de comportement</h3>
+<ul>
+<li><strong>Avant</strong>: Délai de 200ms + cooldown de 2s entre les
+rechargements de cache</li>
+<li><strong>Après</strong>: Rechargement immédiat dès l’invalidation du
+cache</li>
+<li><strong>Impact</strong>: Réactivité améliorée de l’interface, les
+mises à jour apparaissent immédiatement</li>
+</ul>
+<h3 id="réduction-de-complexité">Réduction de complexité</h3>
+<ul>
+<li><strong>3 variables supprimées</strong>:
+<code>refreshTimeoutId</code>, <code>lastRefreshTime</code>,
+<code>REFRESH_COOLDOWN_MS</code></li>
+<li><strong>Logique simplifiée</strong>: De ~40 lignes à ~10 lignes dans
+le watcher</li>
+<li><strong>Code plus lisible</strong>: Intention claire sans mécanismes
+de temporisation complexes</li>
+</ul>
+<h3 id="tests">Tests</h3>
+<ul>
+<li>✓ Le projet compile sans erreurs TypeScript</li>
+<li>✓ Le flag <code>isRefreshing</code> empêche toujours les
+rechargements concurrents</li>
+<li>✓ Les autres composants (useRenderers.ts, VolumeControl.vue)
+conservent leurs optimisations légitimes</li>
+</ul>
+<h2 id="conclusion">Conclusion</h2>
+<p>La suppression du débouncing et du cooldown dans MediaBrowser.vue
+simplifie le code tout en améliorant la réactivité de l’interface.
+Puisque le serveur contrôle déjà le flux SSE, ces mécanismes côté client
+étaient redondants et ajoutaient une latence artificielle.</p>
+<p>Le code est maintenant plus simple, plus réactif, et fait confiance
+au serveur pour contrôler la fréquence des événements SSE.</p>
+<h2 id="fichiers-modifiés">Fichiers modifiés</h2>
+<ul>
+<li><code>pmoapp/webapp/src/components/pmocontrol/MediaBrowser.vue</code></li>
+</ul>
+<h2 id="lignes-de-code">Lignes de code</h2>
+<ul>
+<li><strong>Supprimées</strong>: ~35 lignes (logique de
+débouncing/cooldown)</li>
+<li><strong>Ajoutées</strong>: ~5 lignes (logique simplifiée)</li>
+<li><strong>Net</strong>: -30 lignes</li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/Report_config_ext.html

@@ -0,0 +1,152 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>config_ext</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1 id="rapport-documentation-du-pattern-dextension-pmoconfig">Rapport :
+Documentation du pattern d’extension pmoconfig</h1>
+<h2 id="objectif-de-la-tâche">Objectif de la tâche</h2>
+<p>Créer une fiche descriptive documentant le pattern d’implémentation
+des traits d’extension de <code>pmoconfig::Config</code> en analysant
+les implémentations existantes dans les différents crates du projet.</p>
+<h2 id="travail-réalisé">Travail réalisé</h2>
+<h3 id="analyse-des-fichiers-source">1. Analyse des fichiers source</h3>
+<p>Les fichiers suivants ont été analysés :</p>
+<ul>
+<li><code>pmocovers/src/config_ext.rs</code> - Pattern cache avec
+conversion WebP</li>
+<li><code>pmoaudiocache/src/config_ext.rs</code> - Pattern cache avec
+conversion FLAC</li>
+<li><code>pmoqobuz/src/config_ext.rs</code> - Pattern authentification
+et rate limiting</li>
+<li><code>pmocache/src/config_ext.rs</code> - Trait générique de cache
+et macro</li>
+<li><code>pmoconfig/PASSWORD_ENCRYPTION.md</code> - Documentation du
+chiffrement</li>
+<li><code>pmoupnp/src/config_ext.rs</code> - Pattern configuration
+UPnP</li>
+<li><code>pmoparadise/src/config_ext.rs</code> - Pattern configuration
+minimale</li>
+</ul>
+<h3 id="patterns-identifiés">2. Patterns identifiés</h3>
+<h4 id="pattern-de-base">Pattern de base</h4>
+<p>Tous les traits d’extension suivent la même structure : - Trait
+public avec méthodes getter/setter - Implémentation pour
+<code>pmoconfig::Config</code> - Utilisation de
+<code>get_value</code>/<code>set_value</code> génériques - Constantes
+pour valeurs par défaut</p>
+<h4 id="patterns-spécialisés">Patterns spécialisés</h4>
+<ul>
+<li><strong>Cache</strong> : Utilisation de <code>CacheConfigExt</code>
+et factory methods</li>
+<li><strong>Authentification</strong> : Getters combinés, helpers de
+validation, déchiffrement automatique</li>
+<li><strong>Rate limiting</strong> : Configuration des limites avec
+valeurs par défaut</li>
+<li><strong>Configuration minimale</strong> : Auto-persistence des
+valeurs par défaut</li>
+<li><strong>UPnP</strong> : Configuration des identifiants devices</li>
+</ul>
+<h3 id="structure-de-la-documentation">3. Structure de la
+documentation</h3>
+<p>La documentation créée couvre :</p>
+<ol type="1">
+<li><strong>Vue d’ensemble</strong> : Objectif et principe du
+pattern</li>
+<li><strong>Architecture</strong> : Structure et flux de données</li>
+<li><strong>Implémentation</strong> : Guide détaillé avec patterns de
+code</li>
+<li><strong>Patterns spécialisés</strong> : Exemples pour chaque cas
+d’usage</li>
+<li><strong>Bonnes pratiques</strong> : Nommage, erreurs,
+documentation</li>
+<li><strong>Exemples complets</strong> : 3 implémentations complètes
+commentées</li>
+<li><strong>Checklist</strong> : Liste de vérification pour nouveaux
+traits</li>
+<li><strong>Philosophie</strong> : Principes directeurs et
+avantages</li>
+</ol>
+<h3 id="contenu-clé">4. Contenu clé</h3>
+<h4 id="patterns-de-getters">Patterns de getters</h4>
+<ul>
+<li>Getter simple avec valeur par défaut</li>
+<li>Getter avec auto-persistence</li>
+<li>Getter optionnel</li>
+<li>Getter avec déchiffrement</li>
+<li>Getter avec parsing et fallback</li>
+</ul>
+<h4 id="patterns-de-setters">Patterns de setters</h4>
+<ul>
+<li>Setter simple</li>
+<li>Setter avec transformation</li>
+<li>Setter multiple (transaction)</li>
+<li>Setter de nettoyage</li>
+</ul>
+<h4 id="helpers">Helpers</h4>
+<ul>
+<li>Factory methods</li>
+<li>Getters combinés</li>
+<li>Helpers de validation</li>
+</ul>
+<h3 id="hiérarchie-de-configuration-yaml">5. Hiérarchie de configuration
+YAML</h3>
+<p>Documentation des chemins standards : - <code>host.*</code> :
+Configuration hôte/système - <code>accounts.*</code> : Comptes et
+services - <code>sources.*</code> : Sources de médias</p>
+<h2 id="résultat">Résultat</h2>
+<p>Le document <code>Blackboard/Architecture/pmoconfig_ext.md</code> a
+été créé avec : - 800+ lignes de documentation complète - 3 exemples
+d’implémentation complète - Patterns pour tous les cas d’usage
+identifiés - Bonnes pratiques et anti-patterns - Checklist
+d’implémentation</p>
+<h2 id="fichiers-créés-ou-modifiés">Fichiers créés ou modifiés</h2>
+<ul>
+<li><strong>Créé</strong> :
+<code>Blackboard/Architecture/pmoconfig_ext.md</code> - Documentation
+complète du pattern</li>
+<li><strong>Créé</strong> : <code>Blackboard/Report/config_ext.md</code>
+- Ce rapport</li>
+</ul>
+<h2 id="conformité-avec-rules.md">Conformité avec Rules.md</h2>
+<ul>
+<li>Documentation placée dans <code>Blackboard/Architecture/</code>
+comme demandé</li>
+<li>Rapport créé dans <code>Blackboard/Report/</code> avec le même nom
+de fichier</li>
+<li>Analyse focalisée sur l’objectif principal</li>
+<li>Documentation prête pour classification (Done/ToDiscuss) par
+l’humain</li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/Report_music_source.html

@@ -0,0 +1,238 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>music_source</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1
+id="rapport-documentation-dimplémentation-dune-nouvelle-musicsource">Rapport
+: Documentation d’implémentation d’une nouvelle MusicSource</h1>
+<h2 id="objectif">Objectif</h2>
+<p>Créer une documentation complète et pratique pour guider
+l’implémentation d’une nouvelle source musicale dans l’écosystème
+PMOMusic.</p>
+<h2 id="travail-réalisé">Travail réalisé</h2>
+<h3 id="analyse-des-sources-existantes">1. Analyse des sources
+existantes</h3>
+<p>J’ai analysé deux implémentations de référence :</p>
+<ul>
+<li><strong>pmoparadise/src/source.rs</strong> : Source dynamique avec
+FIFO (radio streaming)</li>
+<li><strong>pmoqobuz/src/source.rs</strong> : Source catalogue avec
+playlists lazy</li>
+</ul>
+<p>Ainsi que la documentation du trait :</p>
+<ul>
+<li><strong>pmosource/README.md</strong> : Vue d’ensemble du trait
+MusicSource</li>
+<li><strong>pmosource/ARCHITECTURE.md</strong> : Architecture et design
+decisions</li>
+</ul>
+<h3 id="identification-des-patterns-principaux">2. Identification des
+patterns principaux</h3>
+<p>Deux patterns majeurs ont été identifiés :</p>
+<h4 id="pattern-1-source-dynamique-fifo-radio-paradise">Pattern 1 :
+Source dynamique FIFO (Radio Paradise)</h4>
+<p><strong>Caractéristiques :</strong> - Flux continu de tracks avec
+capacité limitée - Suppression automatique des plus anciens - Callbacks
+sur playlists pour détecter les changements - Notification du
+ContentDirectory via notifier injecté - Adaptation des IDs playlist →
+schema source</p>
+<p><strong>Éléments clés :</strong></p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>update_counter<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;&gt;</span></span>
+<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a>last_change<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span>SystemTime<span class="op">&gt;&gt;</span></span>
+<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a>callback_tokens<span class="op">:</span> Arc<span class="op">&lt;</span>Mutex<span class="op">&lt;</span><span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">u64</span><span class="op">&gt;&gt;&gt;</span></span>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a>container_notifier<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span>Arc<span class="op">&lt;</span><span class="kw">dyn</span> <span class="bu">Fn</span>(<span class="op">&amp;</span>[<span class="dt">String</span>]) <span class="op">+</span> <span class="bu">Send</span> <span class="op">+</span> <span class="bu">Sync</span><span class="op">&gt;&gt;</span></span></pre></div>
+<h4 id="pattern-2-source-catalogue-lazy-qobuz">Pattern 2 : Source
+catalogue lazy (Qobuz)</h4>
+<p><strong>Caractéristiques :</strong> - Catalogue vaste avec navigation
+hiérarchique - Cache lazy pour audio, eager pour covers - Playlists
+créées à la demande avec TTL - LazyProvider pour télécharger l’audio à
+la lecture - Métadonnées riches stockées dans le cache</p>
+<p><strong>Éléments clés :</strong></p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>SourceCacheManager centralisé</span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a>QobuzLazyProvider implémentant LazyProvider</span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a>Playlists avec rôle Album et TTL de <span class="dv">7</span> jours</span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a>Adaptation IDs avec metadata source_track_id</span></pre></div>
+<h3 id="structure-du-document-créé">3. Structure du document créé</h3>
+<p>Le document <code>Blackboard/Architecture/music_source.md</code>
+contient :</p>
+<h4 id="table-des-matières">Table des matières</h4>
+<ol type="1">
+<li>Vue d’ensemble</li>
+<li>Structure d’une MusicSource</li>
+<li>Implémentation du trait MusicSource</li>
+<li>Patterns d’implémentation</li>
+<li>Intégration avec l’écosystème PMOMusic</li>
+<li>Checklist de mise en œuvre</li>
+<li>Exemples de référence</li>
+</ol>
+<h4 id="sections-détaillées">Sections détaillées</h4>
+<p><strong>Section 1 : Vue d’ensemble</strong> - Définition d’une
+MusicSource - Types de sources (dynamique vs statique) - Capacités du
+trait</p>
+<p><strong>Section 2 : Structure</strong> - Organisation du code -
+Dépendances recommandées - Features Cargo</p>
+<p><strong>Section 3 : Implémentation du trait</strong> - Informations
+de base (name, id, default_image) - Navigation ContentDirectory
+(root_container, browse, resolve_uri) - Support FIFO (append_track,
+remove_oldest, update_id) - Support statique (get_items, search)</p>
+<p><strong>Section 4 : Patterns</strong> - Pattern 1 : Source dynamique
+avec FIFO (code complet) - Pattern 2 : Source catalogue avec playlists
+lazy (code complet) - Pattern 3 : Adaptation des IDs entre playlist et
+source</p>
+<p><strong>Section 5 : Intégration écosystème</strong> - pmoplaylist :
+création et gestion de playlists - pmoaudiocache/pmocovers via
+SourceCacheManager - pmodidl : conversion vers DIDL-Lite - LazyProvider
+personnalisé</p>
+<p><strong>Section 6 : Checklist</strong> - Phase 1 : Structure de base
+- Phase 2 : Navigation ContentDirectory - Phase 3 : Résolution d’URI -
+Phase 4 : Support FIFO (si dynamique) - Phase 5 : Support statique (si
+catalogue) - Phase 6 : Intégration avancée - Phase 7 : Tests et
+validation</p>
+<p><strong>Section 7 : Exemples de référence</strong> - Radio Paradise
+(source dynamique FIFO) - Qobuz (source catalogue lazy) - Schemas
+d’Object ID détaillés</p>
+<h3 id="points-techniques-importants-documentés">4. Points techniques
+importants documentés</h3>
+<h4 id="schema-dobject-id">Schema d’Object ID</h4>
+<p>Format recommandé hiérarchique :</p>
+<pre><code>&lt;source-id&gt;
+&lt;source-id&gt;:albums
+&lt;source-id&gt;:album:&lt;album_id&gt;
+&lt;source-id&gt;:track:&lt;track_id&gt;
+&lt;source-id&gt;:playlist:&lt;playlist_id&gt;</pre>
+<p>Exemples concrets de Radio Paradise et Qobuz fournis.</p>
+<h4 id="adaptation-des-ids">Adaptation des IDs</h4>
+<p>Code complet pour adapter les items de playlist au schema de la
+source : - Extraction du cache_pk depuis l’URL - Récupération du
+source_track_id depuis metadata - Reconstruction de l’ID correct -
+Normalisation des URLs (relatives → absolues) - Ajout de champs requis
+(genre)</p>
+<h4 id="cache-lazy-vs-eager">Cache lazy vs eager</h4>
+<p>Stratégie claire : - <strong>Covers</strong> : Cache eager (petit, UI
+en a besoin immédiatement) - <strong>Audio</strong> : Cache lazy (grand,
+téléchargé à la demande)</p>
+<h4 id="thread-safety">Thread Safety</h4>
+<p>Règles explicites : - <code>Arc&lt;RwLock&lt;&gt;&gt;</code> pour
+état mutable partagé - <code>tokio::sync::RwLock</code> pour async -
+Éviter <code>Rc&lt;&gt;</code>, <code>RefCell</code> (non thread-safe) -
+Implémenter <code>Clone</code> via <code>Arc&lt;&gt;</code></p>
+<h4 id="compatibilité-upnp">Compatibilité UPnP</h4>
+<p>Points de vigilance : - Genre obligatoire pour certains clients
+(gupnp-av-cp) - URLs absolues uniquement - Protocol Info correct pour
+FLAC - Duration au format <code>H:MM:SS</code> - childCount optionnel
+mais recommandé</p>
+<h3 id="code-dexemple-complet">5. Code d’exemple complet</h3>
+<p>Le document contient des exemples de code complets et fonctionnels
+pour :</p>
+<ol type="1">
+<li><strong>Structure de base</strong> : définition de la struct et
+implémentation basique</li>
+<li><strong>Navigation</strong> : root_container et browse avec pattern
+matching</li>
+<li><strong>Résolution URI</strong> : avec fallback cache →
+original</li>
+<li><strong>FIFO</strong> : append_track, remove_oldest, callbacks</li>
+<li><strong>Adaptation IDs</strong> : fonction complète
+d’adaptation</li>
+<li><strong>LazyProvider</strong> : implémentation personnalisée</li>
+<li><strong>Conversion DIDL</strong> : traits ToDIDLContainer et
+ToDIDLItem</li>
+</ol>
+<h2 id="couverture-des-besoins">Couverture des besoins</h2>
+<h3 id="sources-couvertes">Sources couvertes</h3>
+<ul>
+<li>✅ Radio Paradise : source dynamique FIFO</li>
+<li>✅ Qobuz : source catalogue lazy</li>
+<li>✅ Patterns génériques applicables à d’autres sources</li>
+</ul>
+<h3 id="cas-dusage-couverts">Cas d’usage couverts</h3>
+<ul>
+<li>✅ Source radio/streaming live</li>
+<li>✅ Source catalogue de streaming (Spotify, Deezer, etc.)</li>
+<li>✅ Source bibliothèque locale</li>
+<li>✅ Source playlists fixes</li>
+<li>✅ Source avec authentification (via client)</li>
+</ul>
+<h3 id="intégrations-couvertes">Intégrations couvertes</h3>
+<ul>
+<li>✅ pmoplaylist (FIFO et persistant)</li>
+<li>✅ pmoaudiocache (cache audio)</li>
+<li>✅ pmocovers (cache covers)</li>
+<li>✅ SourceCacheManager (centralisé)</li>
+<li>✅ LazyProvider (téléchargement lazy)</li>
+<li>✅ pmodidl (DIDL-Lite)</li>
+</ul>
+<h2 id="limitations-et-améliorations-futures">Limitations et
+améliorations futures</h2>
+<h3 id="limitations-actuelles">Limitations actuelles</h3>
+<ol type="1">
+<li><strong>Search</strong> : Pas d’exemple détaillé de search
+(optionnel dans le trait)</li>
+<li><strong>Authentification</strong> : Mentionné mais pas d’exemple
+complet</li>
+<li><strong>Multi-format</strong> : Pas d’exemple de source supportant
+plusieurs formats</li>
+<li><strong>Offline</strong> : Pas de pattern pour source
+offline/synchronisation</li>
+</ol>
+<h3 id="améliorations-possibles">Améliorations possibles</h3>
+<ol type="1">
+<li>Ajouter un exemple complet de search avec filtres</li>
+<li>Documenter l’intégration avec un système d’auth OAuth</li>
+<li>Ajouter un pattern pour sources multi-formats (FLAC/MP3/AAC)</li>
+<li>Documenter la gestion offline avec synchronisation</li>
+</ol>
+<h2 id="fichiers-créés">Fichiers créés</h2>
+<ul>
+<li><code>Blackboard/Architecture/music_source.md</code> : Documentation
+complète (15 sections, ~800 lignes)</li>
+</ul>
+<h2 id="conclusion">Conclusion</h2>
+<p>Le document créé fournit un guide complet et pratique pour
+implémenter une nouvelle MusicSource. Il combine :</p>
+<ul>
+<li><strong>Théorie</strong> : Architecture, design patterns,
+principes</li>
+<li><strong>Pratique</strong> : Code complet, exemples réels,
+checklist</li>
+<li><strong>Référence</strong> : Schemas d’Object ID, intégrations,
+compatibilité</li>
+</ul>
+<p>Un développeur peut suivre ce guide étape par étape pour créer une
+nouvelle source musicale compatible avec l’écosystème PMOMusic, en
+s’inspirant des patterns éprouvés de Radio Paradise et Qobuz.</p>
+</article>
+</body>
+</html>

Blackboard_HTML/Report_pmoserver_ext.html

@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>pmoserver_ext</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<h1 id="rapport-documentation-du-pattern-pmoserver_ext">Rapport :
+Documentation du pattern pmoserver_ext</h1>
+<h2 id="contexte">Contexte</h2>
+<p>Documentation du pattern d’extension du PMOServer à travers plusieurs
+itérations basées sur les retours utilisateur.</p>
+<h2 id="travail-réalisé">Travail réalisé</h2>
+<h3 id="analyse-des-fichiers-sources">Analyse des fichiers sources</h3>
+<p>Les fichiers suivants ont été analysés pour extraire le pattern :</p>
+<ul>
+<li><code>pmoapp/src/lib.rs</code> : Pattern SPA avec RustEmbed</li>
+<li><code>pmocontrol/src/pmoserver_ext.rs</code> : API REST avec Control
+Point (1506+ lignes)</li>
+<li><code>pmoparadise/src/pmoserver_ext.rs</code> : API REST simple avec
+client externe</li>
+<li><code>pmoaudiocache/src/lib.rs</code> : Extension avec cache et
+fichiers</li>
+<li><code>pmomediaserver/src/paradise_streaming.rs</code> : Extension
+complexe avec streaming</li>
+</ul>
+<h3 id="round-1-document-initial">Round 1 : Document initial</h3>
+<p>Premier jet documentant exhaustivement tous les aspects des
+extensions (~850 lignes).</p>
+<h3 id="round-2-recentrage-sur-le-pattern">Round 2 : Recentrage sur le
+pattern</h3>
+<p><strong>Annotation</strong> : “se recentrer sur le sujet
+principal”</p>
+<p><strong>Actions</strong> : - Réduction de ~850 à ~400 lignes -
+Suppression des digressions (OpenAPI détaillé, handlers spécifiques) -
+Focus sur l’anatomie du pattern en 5 étapes - Ajout d’une checklist et
+d’un exemple minimal</p>
+<p><strong>Résultat</strong> : Document focalisé sur l’implémentation du
+pattern uniquement.</p>
+<h3 id="round-3-réintégration-openapi">Round 3 : Réintégration
+OpenAPI</h3>
+<p><strong>Annotation</strong> : “Je trouve que le fait de devoir
+déclarer et documenter les URL dans OpenAPI / utopia était quelque chose
+d’important. Remets le.”</p>
+<p><strong>Actions</strong> : - Ajout d’une section complète
+“Documentation OpenAPI avec utoipa” (~260 lignes) - 5 sous-sections
+détaillées : 1. Configuration de base (dépendances Cargo) 2. Définition
+des schémas avec <code>#[derive(ToSchema)]</code> 3. Annotation des
+handlers avec <code>#[utoipa::path]</code> 4. Création de la structure
+<code>#[derive(OpenApi)]</code> 5. Exemple complet extrait de Radio
+Paradise - Mise à jour de la checklist avec section “Documentation
+OpenAPI” - Ajout des dépendances <code>utoipa</code> et
+<code>serde</code> dans la section références</p>
+<p><strong>Positionnement</strong> : Section insérée après “Méthodes
+disponibles du serveur” et avant “Patterns courants”, car elle fait
+partie intégrante de l’implémentation.</p>
+<h2 id="structure-finale-du-document">Structure finale du document</h2>
+<ol type="1">
+<li><strong>Vue d’ensemble</strong> : Principe du pattern</li>
+<li><strong>Anatomie d’une extension</strong> : 5 étapes détaillées</li>
+<li><strong>Méthodes disponibles du serveur</strong> : API de
+<code>pmoserver::Server</code></li>
+<li><strong>Documentation OpenAPI avec utoipa</strong> : Guide complet
+en 5 étapes ⭐ <em>Ajouté au Round 3</em></li>
+<li><strong>Patterns courants</strong> : 3 exemples concrets</li>
+<li><strong>Gestion des opérations longues</strong> : spawn_blocking,
+timeouts, background tasks</li>
+<li><strong>Checklist d’implémentation</strong> : Organisée par
+catégories</li>
+<li><strong>Exemple complet minimal</strong> : Code fonctionnel</li>
+<li><strong>Références</strong> : Fichiers sources et dépendances</li>
+</ol>
+<h2 id="résultat-final">Résultat final</h2>
+<p>Le document est maintenant :</p>
+<ul>
+<li><strong>Complet</strong> : Couvre tous les aspects essentiels
+incluant OpenAPI</li>
+<li><strong>Structuré</strong> : Progression logique de la configuration
+à l’implémentation</li>
+<li><strong>Pratique</strong> : Exemples de code concrets extraits du
+codebase</li>
+<li><strong>Actionnable</strong> : Checklist détaillée en 4
+catégories</li>
+</ul>
+<p>Taille finale : ~660 lignes (avec section OpenAPI complète)</p>
+<h2 id="fichiers-modifiés">Fichiers modifiés</h2>
+<ul>
+<li><code>Blackboard/Architecture/pmoserver_ext.md</code> : Document
+complet avec OpenAPI (660 lignes)</li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/ToDiscuss_Pinnable_cache_item.html

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Pinnable_cache_item</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<p><strong>Il faut suivre les instructions générales placées dans le
+fichier : Blackboard/Rules.md</strong></p>
+<p>La crâte PMOcache, implémente un system de cache qui pourrait être
+étendu pour permettre une utilisation plus large. L’idée est de modifier
+les règles de déletion des items. Actuellement le cache a une capacité
+maximale. Et les items ont des TTL, qui peuvent être non définies.
+Lorsque le cash est plein, les plus vieux items en termes d’utilisation
+ou ceux qui ont dépassé leur TTL peuvent être détruits. Je propose de
+rajouter une fonctionnalité qui permet d’épingler certains items pour
+les rendre non destructibles. Ils pourraient aussi sortir du comptage
+général des items pour savoir si le cache est plein.</p>
+<p>Il faudra modifier la structure de la base de données. Ajouter une
+colonne indiquant cette propriété. Mettre une règle métier en disant
+qu’on ne peut pas être à la fois épinglés et avec un TTL.</p>
+<p>On se moque de maintenir la compatibilité avec la base de données
+actuelle, il n’y a pas à prévoir de phase de transition. Nous sommes en
+période de développement.</p>
+</article>
+</body>
+</html>

Blackboard_HTML/ToDiscuss_pmoserver_ext.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>pmoserver_ext</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<p><strong>Il faut suivre les instructions générales placées dans le
+fichier : Blackboard/Rules.md</strong></p>
+<p>Partir des fichiers suivants:</p>
+<ul>
+<li>pmoapp/src/lib.rs</li>
+<li>pmocontrol/src/pmoserver_ext.rs</li>
+<li>pmoparadise/src/pmoserver_ext.rs</li>
+<li>pmoaudiocache/src/lib.rs</li>
+<li>pmomediaserver/src/paradise_streaming.rs</li>
+</ul>
+<p>réalise une fiche descriptive sur le pattern à réaliser pour
+implémenter un trait d’extension du PMO serveur.</p>
+<p>Le résultat sera une documentation d’implémentation qui sera placé
+dans le fichier:
+<code>Blackboard/Architecture/pmoserver_ext.md</code></p>
+<h2 id="round-2">Round 2</h2>
+<p>J’ai regardé ton document généré et je trouve que tu t’élargis du
+sujet central documenter lecture d’une extension PMOserver. Peux-tu te
+recentrer sur le sujet principal.</p>
+<h2 id="round-3">Round 3</h2>
+<p>Je trouve que le fait de devoir déclarer et documenter les URL dans
+OpenAPI / utopia était quelque chose d’important. Remets le.</p>
+</article>
+</body>
+</html>

Blackboard_HTML/ToThinkAbout_MusicBoxSource.html

@@ -0,0 +1,563 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>MusicBoxSource</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<p><strong>Il faut suivre les instructions générales placées dans le
+fichier : Blackboard/Rules.md</strong></p>
+<h1 id="musicboxsource-bibliothèque-musicale-universelle">MusicBoxSource
+: Bibliothèque musicale universelle</h1>
+<p>Créer une <strong>“boîte à musique”</strong> personnelle : un
+catalogue unifié de morceaux provenant de n’importe quelle source
+(Qobuz, URLs, fichiers locaux, Radio Paradise, etc.), avec taxonomie de
+tags et playlists intelligentes.</p>
+<hr />
+<h2 id="vision">🎯 Vision</h2>
+<h3 id="concept">Concept</h3>
+<p><strong>MusicBoxSource</strong> est une bibliothèque musicale
+curatoriale qui permet de : - <strong>Collecter</strong> : Ajouter des
+morceaux depuis n’importe quelle source PMOMusic ou URL -
+<strong>Organiser</strong> : Classifier avec une taxonomie de tags
+extensible - <strong>Requêter</strong> : Créer des playlists statiques
+et smart playlists (requêtes dynamiques) - <strong>Exposer</strong> :
+Servir via UPnP/DIDL-Lite avec navigation multi-axes</p>
+<h3 id="différence-avec-pmoplaylist">Différence avec
+<code>pmoplaylist</code></h3>
+<ul>
+<li><strong><code>pmoplaylist</code></strong> : Playlists FIFO
+<strong>éphémères</strong> pour sources live (Radio Paradise)</li>
+<li><strong><code>pmomusicbox</code></strong> : Bibliothèque
+<strong>persistante</strong> cross-sources avec métadonnées
+enrichies</li>
+</ul>
+<hr />
+<h2 id="architecture-globale">🏛️ Architecture globale</h2>
+<pre class="mermaid">flowchart TB
+    subgraph Sources[Sources PMOMusic]
+        QOBUZ[pmoqobuz]
+        PARADISE[pmoparadise]
+        LOCAL[pmolocal - à créer]
+        URL[URLs directes]
+    end
+    
+    subgraph Import[Import Layer]
+        IMPORTER[MusicBox Importer]
+        JSPF[pmojspf - Parser playlists]
+        META[pmometadata - Extraction]
+    end
+    
+    subgraph Core[pmomusicbox Core]
+        DB[(SQLite Database)]
+        TAXONOMY[Taxonomie Tags]
+        QUERY[Smart Query Engine]
+    end
+    
+    subgraph Cache[Cache Layer]
+        AUDIO[pmoaudiocache]
+        COVERS[pmocovers]
+    end
+    
+    subgraph Export[Export UPnP]
+        SOURCE[MusicSource Trait]
+        DIDL[DIDL-Lite Generator]
+        BROWSE[Multi-Axis Browser]
+    end
+    
+    Sources --&gt; IMPORTER
+    URL --&gt; IMPORTER
+    JSPF --&gt; IMPORTER
+    META --&gt; IMPORTER
+    
+    IMPORTER --&gt; DB
+    DB --&gt; TAXONOMY
+    DB --&gt; QUERY
+    
+    DB &lt;--&gt; AUDIO
+    DB &lt;--&gt; COVERS
+    
+    DB --&gt; SOURCE
+    TAXONOMY --&gt; BROWSE
+    QUERY --&gt; BROWSE
+    SOURCE --&gt; DIDL
+    BROWSE --&gt; DIDL</pre>
+<hr />
+<h2 id="modèle-de-données-sqlite">🗄️ Modèle de données (SQLite)</h2>
+<h3 id="tables-principales">Tables principales</h3>
+<pre class="mermaid">erDiagram
+    TAG_CATEGORIES ||--o{ TAGS : contient
+    TAG_CATEGORIES ||--o{ TAG_CATEGORIES : parent
+    TAGS ||--o{ ITEM_TAGS : associe
+    MUSIC_ITEMS ||--o{ ITEM_TAGS : a
+    MUSIC_ITEMS ||--o{ PLAYLIST_ITEMS : dans
+    PLAYLISTS ||--o{ PLAYLIST_ITEMS : contient
+    
+    TAG_CATEGORIES {
+        text id PK &quot;Ex: mood, genre&quot;
+        text name &quot;Nom affiché&quot;
+        text parent_id FK &quot;Hiérarchie&quot;
+        text color &quot;Hex color&quot;
+        text icon &quot;Emoji/icon&quot;
+        int display_order
+    }
+    
+    TAGS {
+        text id PK &quot;Ex: mood:energetic&quot;
+        text category_id FK
+        text name &quot;energetic, chill&quot;
+        text description
+        text color &quot;Override&quot;
+    }
+    
+    MUSIC_ITEMS {
+        text id PK &quot;UUID&quot;
+        text source_type &quot;qobuz, url, local&quot;
+        text source_id &quot;ID source&quot;
+        text original_uri &quot;URI source&quot;
+        text cache_audio_pk FK &quot;pmoaudiocache&quot;
+        text cache_cover_pk FK &quot;pmocovers&quot;
+        text title
+        text artist
+        text album
+        int year
+        int rating &quot;1-5 étoiles&quot;
+        int play_count
+    }
+    
+    ITEM_TAGS {
+        text item_id PK,FK
+        text tag_id PK,FK
+        int added_at
+        text source &quot;user, auto&quot;
+    }
+    
+    PLAYLISTS {
+        text id PK
+        text name
+        bool is_smart
+        text smart_query &quot;JSON&quot;
+    }
+    
+    PLAYLIST_ITEMS {
+        text playlist_id PK,FK
+        text item_id FK
+        int position PK
+    }</pre>
+<h3 id="tables-dassociation">Tables d’association</h3>
+<ul>
+<li><strong><code>item_tags</code></strong> : Liens items ↔︎ tags
+(N:M)</li>
+<li><strong><code>playlist_items</code></strong> : Items dans playlists
+statiques (position, ordre)</li>
+<li><strong><code>tag_synonyms</code></strong> : Synonymes pour
+recherche (ex: “jazz” → “swing”)</li>
+</ul>
+<h3 id="index-recherche">Index &amp; Recherche</h3>
+<ul>
+<li><strong>Indexes B-tree</strong> : artist, album, genre, year,
+rating, play_count</li>
+<li><strong>FTS5 (Full-Text Search)</strong> : title, artist, album,
+comment</li>
+<li><strong>Triggers</strong> : Maintien des tables FTS en sync avec
+<code>music_items</code></li>
+</ul>
+<hr />
+<h2 id="taxonomie-par-défaut">🎨 Taxonomie par défaut</h2>
+<p>Catégories préchargées à l’initialisation :</p>
+<table>
+<colgroup>
+<col style="width: 14%" />
+<col style="width: 37%" />
+<col style="width: 48%" />
+</colgroup>
+<thead>
+<tr>
+<th>Catégorie</th>
+<th>Description</th>
+<th>Exemples de tags</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><strong>Mood</strong></td>
+<td>État d’esprit, émotion</td>
+<td>energetic, chill, melancholic, happy</td>
+</tr>
+<tr>
+<td><strong>Genre</strong></td>
+<td>Style musical</td>
+<td>rock, jazz, classical, electronic, metal</td>
+</tr>
+<tr>
+<td><strong>Era</strong></td>
+<td>Période, décennie</td>
+<td>60s, 70s, 80s, 90s, contemporary</td>
+</tr>
+<tr>
+<td><strong>Occasion</strong></td>
+<td>Contexte d’écoute</td>
+<td>workout, focus, party, driving, sleep</td>
+</tr>
+<tr>
+<td><strong>Tempo</strong></td>
+<td>Vitesse</td>
+<td>slow, medium, fast</td>
+</tr>
+<tr>
+<td><strong>Instrument</strong></td>
+<td>Instrument dominant</td>
+<td>piano, guitar, vocal, synthesizer</td>
+</tr>
+<tr>
+<td><strong>Quality</strong></td>
+<td>Qualité audio</td>
+<td>lossless, high-res, remastered, live</td>
+</tr>
+<tr>
+<td><strong>Origin</strong></td>
+<td>Origine géographique</td>
+<td>usa, uk, france, japan, latin, africa</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Extensibilité</strong> : L’utilisateur peut créer ses propres
+catégories et tags.</p>
+<hr />
+<h2 id="crates-architecture">📦 Crates architecture</h2>
+<h3 id="pmojspf---parser-de-playlists-utilitaire">1.
+<strong><code>pmojspf</code></strong> - Parser de playlists
+(utilitaire)</h3>
+<p><strong>But</strong> : Parser/écrire différents formats de playlists
+vers/depuis un format pivot JSPF (JSON).</p>
+<pre><code>pmojspf/
+├── model.rs        # Structures JSPF (Playlist, Track, Meta)
+├── reader/
+│   ├── jspf.rs     # JSON natif
+│   ├── xspf.rs     # XML (via quick-xml ou crate xspf)
+│   ├── m3u.rs      # M3U/M3U8 (parsing ligne par ligne)
+│   └── pls.rs      # PLS (format INI-like)
+└── writer.rs       # Export JSPF</pre>
+<p><strong>Dépendances</strong> : <code>serde</code>,
+<code>serde_json</code>, <code>quick-xml</code> (ou <code>xspf</code>
+crate)</p>
+<p><strong>Usage</strong> : Réutilisé par <code>pmomusicbox</code> pour
+import/export</p>
+<hr />
+<h3 id="pmomusicbox---bibliothèque-musicale-core">2.
+<strong><code>pmomusicbox</code></strong> - Bibliothèque musicale
+core</h3>
+<p><strong>Responsabilités</strong> : - Gestion base SQLite (CRUD items,
+tags, playlists) - Import depuis sources PMO (Qobuz, Paradise, Local,
+URLs) - Smart playlists (query builder + exécution SQL) - Implémentation
+<code>MusicSource</code> trait (exposition UPnP) - Intégration caches
+audio/covers</p>
+<pre><code>pmomusicbox/
+├── db/
+│   ├── schema.rs       # DDL SQLite + migrations
+│   ├── items.rs        # CRUD music_items
+│   ├── tags.rs         # CRUD tags + taxonomie
+│   ├── playlists.rs    # CRUD playlists statiques
+│   ├── smart.rs        # Smart playlists
+│   └── search.rs       # Full-text search (FTS5)
+│
+├── import/
+│   ├── url.rs          # Import URL directe
+│   ├── source.rs       # Import depuis MusicSource
+│   ├── local.rs        # Import fichiers locaux (via pmometadata)
+│   └── playlist.rs     # Import JSPF/M3U8 (via pmojspf)
+│
+├── export/
+│   └── playlist.rs     # Export playlists (JSPF, M3U8)
+│
+├── query/
+│   ├── builder.rs      # SmartPlaylistQuery (DSL)
+│   └── executor.rs     # Génération + exécution SQL
+│
+├── didl/
+│   └── generator.rs    # Conversion items → DIDL-Lite
+│
+├── source.rs           # Impl MusicSource trait
+├── taxonomy.rs         # Taxonomie par défaut + CRUD
+└── config_ext.rs       # Extension pmoconfig</pre>
+<p><strong>Dépendances</strong> : - <code>pmosource</code>,
+<code>pmoaudiocache</code>, <code>pmocovers</code>,
+<code>pmodidl</code>, <code>pmometadata</code> - <code>pmojspf</code>
+(import/export playlists) - <code>rusqlite</code> (features:
+<code>bundled</code>, <code>serde_json</code>) - <code>uuid</code>,
+<code>serde</code>, <code>tokio</code>, <code>async-trait</code></p>
+<hr />
+<h3 id="pmolocal---source-fichiers-locaux-à-créer">3.
+<strong><code>pmolocal</code></strong> - Source fichiers locaux (à
+créer)</h3>
+<p><strong>But</strong> : Scanner des répertoires locaux et exposer les
+fichiers audio via <code>MusicSource</code>.</p>
+<pre><code>pmolocal/
+├── scanner.rs      # Scan récursif de répertoires
+├── watcher.rs      # Hot reload (notify)
+├── source.rs       # Impl MusicSource
+└── config_ext.rs   # Extension pmoconfig</pre>
+<p><strong>Workflow</strong> : 1. <code>pmolocal</code> scanne
+<code>/home/user/Music</code> 2. <code>pmomusicbox</code> importe les
+items découverts 3. Tags automatiques basés sur métadonnées (genre,
+année)</p>
+<hr />
+<h2 id="flux-dimport">🔄 Flux d’import</h2>
+<h3 id="import-depuis-une-source-pmo-ex-qobuz">Import depuis une source
+PMO (ex: Qobuz)</h3>
+<pre class="mermaid">sequenceDiagram
+    participant QS as Qobuz Source
+    participant MB as MusicBox Importer
+    participant DB as SQLite DB
+    participant AC as pmoaudiocache
+    participant CC as pmocovers
+    
+    QS-&gt;&gt;MB: get_item(object_id)
+    MB-&gt;&gt;QS: resolve_uri(object_id)
+    
+    Note over MB: 1. Extraire métadonnées DIDL-Lite&lt;br/&gt;2. Générer UUID
+    
+    MB-&gt;&gt;DB: INSERT INTO music_items
+    
+    opt Auto-cache activé
+        MB-&gt;&gt;AC: Cache audio
+        MB-&gt;&gt;CC: Cache cover
+        AC--&gt;&gt;DB: Retourner cache_audio_pk
+        CC--&gt;&gt;DB: Retourner cache_cover_pk
+    end
+    
+    MB--&gt;&gt;QS: item_id (UUID)</pre>
+<h3 id="import-url-directe">Import URL directe</h3>
+<pre class="mermaid">flowchart LR
+    URL[URL simple] --&gt; META[&quot;pmometadata&lt;br/&gt;Extraction&quot;]
+    META --&gt; UUID[Générer UUID]
+    UUID --&gt; DB[(&quot;music_items&quot;)]
+    DB --&gt; CACHE{&quot;Auto-cache?&quot;}
+    CACHE --&gt;|Oui| AC[pmoaudiocache]
+    CACHE --&gt;|Non| END[Fin]
+    AC --&gt; END</pre>
+<h3 id="import-playlist-jspfm3u8">Import playlist JSPF/M3U8</h3>
+<pre class="mermaid">flowchart LR
+    FILE[Fichier playlist] --&gt; JSPF[&quot;pmojspf&lt;br/&gt;Parser&quot;]
+    JSPF --&gt; STRUCT[Structure JSPF]
+    STRUCT --&gt; LOOP{&quot;Pour chaque track&quot;}
+    LOOP --&gt; IMPORT[Import comme URL]
+    IMPORT --&gt; DB[(&quot;music_items&quot;)]
+    DB --&gt; PLAYLIST[Créer playlist statique]
+    PLAYLIST --&gt; LINK[Lier tracks à playlist]</pre>
+<hr />
+<h2 id="smart-playlists-query-dsl">🔍 Smart Playlists (Query DSL)</h2>
+<h3 id="concept-1">Concept</h3>
+<p>Les smart playlists sont des <strong>requêtes sauvegardées</strong>
+qui génèrent dynamiquement une liste de tracks.</p>
+<h3 id="structure-de-requête-json">Structure de requête (JSON)</h3>
+<div class="sourceCode" id="cb9"><pre
+class="sourceCode json"><code class="sourceCode json"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="fu">{</span></span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;include_all_tags&quot;</span><span class="fu">:</span> <span class="ot">[</span><span class="st">&quot;mood:energetic&quot;</span><span class="ot">,</span> <span class="st">&quot;genre:rock&quot;</span><span class="ot">]</span><span class="fu">,</span></span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;exclude_tags&quot;</span><span class="fu">:</span> <span class="ot">[</span><span class="st">&quot;mood:melancholic&quot;</span><span class="ot">]</span><span class="fu">,</span></span>
+<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;year_min&quot;</span><span class="fu">:</span> <span class="dv">1980</span><span class="fu">,</span></span>
+<span id="cb9-5"><a href="#cb9-5" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;year_max&quot;</span><span class="fu">:</span> <span class="dv">1989</span><span class="fu">,</span></span>
+<span id="cb9-6"><a href="#cb9-6" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;min_rating&quot;</span><span class="fu">:</span> <span class="dv">4</span><span class="fu">,</span></span>
+<span id="cb9-7"><a href="#cb9-7" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;lossless_only&quot;</span><span class="fu">:</span> <span class="kw">true</span><span class="fu">,</span></span>
+<span id="cb9-8"><a href="#cb9-8" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;order_by&quot;</span><span class="fu">:</span> <span class="st">&quot;play_count&quot;</span><span class="fu">,</span></span>
+<span id="cb9-9"><a href="#cb9-9" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;order&quot;</span><span class="fu">:</span> <span class="st">&quot;desc&quot;</span><span class="fu">,</span></span>
+<span id="cb9-10"><a href="#cb9-10" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;limit&quot;</span><span class="fu">:</span> <span class="dv">50</span></span>
+<span id="cb9-11"><a href="#cb9-11" aria-hidden="true" tabindex="-1"></a><span class="fu">}</span></span></pre></div>
+<h3 id="traduction-sql">Traduction SQL</h3>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode sql"><code class="sourceCode sql"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="kw">SELECT</span> <span class="op">*</span> <span class="kw">FROM</span> music_items</span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="kw">WHERE</span> <span class="kw">id</span> <span class="kw">IN</span> (</span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">SELECT</span> item_id <span class="kw">FROM</span> item_tags <span class="kw">WHERE</span> tag_id <span class="kw">IN</span> (<span class="st">&#39;mood:energetic&#39;</span>, <span class="st">&#39;genre:rock&#39;</span>)</span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">GROUP</span> <span class="kw">BY</span> item_id <span class="kw">HAVING</span> <span class="fu">COUNT</span>(<span class="kw">DISTINCT</span> tag_id) <span class="op">=</span> <span class="dv">2</span>  <span class="co">-- ALL tags</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a>)</span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a><span class="kw">AND</span> <span class="kw">id</span> <span class="kw">NOT</span> <span class="kw">IN</span> (</span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">SELECT</span> item_id <span class="kw">FROM</span> item_tags <span class="kw">WHERE</span> tag_id <span class="op">=</span> <span class="st">&#39;mood:melancholic&#39;</span></span>
+<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a>)</span>
+<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a><span class="kw">AND</span> <span class="dt">year</span> <span class="kw">BETWEEN</span> <span class="dv">1980</span> <span class="kw">AND</span> <span class="dv">1989</span></span>
+<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a><span class="kw">AND</span> rating <span class="op">&gt;=</span> <span class="dv">4</span></span>
+<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a><span class="kw">AND</span> codec <span class="kw">IN</span> (<span class="st">&#39;flac&#39;</span>, <span class="st">&#39;alac&#39;</span>)</span>
+<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a><span class="kw">ORDER</span> <span class="kw">BY</span> play_count <span class="kw">DESC</span></span>
+<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a><span class="kw">LIMIT</span> <span class="dv">50</span>;</span></pre></div>
+<hr />
+<h2 id="exposition-upnp-musicsource">🎭 Exposition UPnP
+(MusicSource)</h2>
+<h3 id="structure-de-navigation">Structure de navigation</h3>
+<pre class="mermaid">graph TB
+    ROOT[musicbox/] --&gt; ARTIST[by-artist/]
+    ROOT --&gt; ALBUM[by-album/]
+    ROOT --&gt; GENRE[by-genre/]
+    ROOT --&gt; TAG[by-tag/]
+    ROOT --&gt; PLAYLISTS[playlists/]
+    ROOT --&gt; SMART[smart-playlists/]
+    ROOT --&gt; FAV[favorites/]
+    ROOT --&gt; RECENT[recent/]
+    
+    ARTIST --&gt; PF[Pink Floyd/]
+    ARTIST --&gt; Q[Queen/]
+    PF --&gt; WALL[The Wall/]
+    PF --&gt; WYWH[Wish You Were Here/]
+    WALL --&gt; ITEM1[Another Brick... 🎵]
+    
+    TAG --&gt; MOOD[mood/]
+    TAG --&gt; OCC[occasion/]
+    TAG --&gt; ERA[era/]
+    
+    MOOD --&gt; ENRG[energetic/]
+    MOOD --&gt; CHILL[chill/]
+    ENRG --&gt; ITEMS1[items taggués 🎵]
+    
+    OCC --&gt; WORK[workout/]
+    OCC --&gt; FOCUS[focus/]
+    
+    ERA --&gt; E80[80s/]
+    ERA --&gt; E90[90s/]
+    
+    PLAYLISTS --&gt; PL1[My Favorites/]
+    PLAYLISTS --&gt; PL2[Summer 2024/]
+    
+    SMART --&gt; SP1[80s Rock Workout/]
+    SMART --&gt; SP2[Jazz Dinner/]
+    
+    style ITEM1 fill:#e1f5ff
+    style ITEMS1 fill:#e1f5ff</pre>
+<h3 id="object-ids">Object IDs</h3>
+<pre><code>musicbox:by-artist:{artist_name}
+musicbox:by-album:{album_id}
+musicbox:by-tag:{category}:{tag_name}
+musicbox:playlist:{playlist_id}
+musicbox:smart:{smart_playlist_id}
+musicbox:item:{item_id}</pre>
+<hr />
+<h2 id="intégration-avec-lécosystème-pmomusic">🔌 Intégration avec
+l’écosystème PMOMusic</h2>
+<h3 id="avec-pmoaudiocache">Avec pmoaudiocache</h3>
+<ul>
+<li>Import → Déclencher cache automatique (si
+<code>auto_cache: true</code>)</li>
+<li><code>resolve_uri()</code> → Retourner URI cachée si disponible</li>
+</ul>
+<h3 id="avec-pmocovers">Avec pmocovers</h3>
+<ul>
+<li>Import → Télécharger cover art</li>
+<li>Browse → Inclure <code>album_art</code> dans DIDL-Lite</li>
+</ul>
+<h3 id="avec-pmoserver-feature-server">Avec pmoserver (feature
+<code>server</code>)</h3>
+<ul>
+<li>API REST pour manipulation (CRUD items, tags, playlists)</li>
+<li>SSE pour notifications de changements</li>
+<li>Endpoints OpenAPI (utoipa)</li>
+</ul>
+<hr />
+<h2 id="plan-dimplémentation-phases">📝 Plan d’implémentation
+(Phases)</h2>
+<h3 id="phase-1-fondations">Phase 1 : Fondations</h3>
+<ul>
+<li>Schéma SQLite complet</li>
+<li>Crate <code>pmojspf</code> (parser playlists)</li>
+<li>CRUD basique dans <code>pmomusicbox</code> (items, tags)</li>
+<li>Taxonomie par défaut</li>
+<li>Import URL simple</li>
+<li>Extension pmoconfig</li>
+</ul>
+<h3 id="phase-2-import-cross-sources">Phase 2 : Import
+cross-sources</h3>
+<ul>
+<li>Import depuis MusicSource (Qobuz, Paradise)</li>
+<li>Import playlists (JSPF/M3U8)</li>
+<li>Intégration caches (audio, covers)</li>
+<li>Crate <code>pmolocal</code> (fichiers locaux)</li>
+</ul>
+<h3 id="phase-3-smart-playlists">Phase 3 : Smart Playlists</h3>
+<ul>
+<li>Query builder (DSL)</li>
+<li>Exécuteur SQL</li>
+<li>CRUD smart playlists</li>
+<li>Export JSPF</li>
+</ul>
+<h3 id="phase-4-musicsource-upnp">Phase 4 : MusicSource UPnP</h3>
+<ul>
+<li>Implémentation trait <code>MusicSource</code></li>
+<li>Génération DIDL-Lite</li>
+<li>Browse multi-axes (artist, album, tag)</li>
+<li>Recherche full-text (FTS5)</li>
+</ul>
+<h3 id="phase-5-fonctionnalités-avancées">Phase 5 : Fonctionnalités
+avancées</h3>
+<ul>
+<li>Statistiques d’écoute (play_count, last_played)</li>
+<li>Auto-tagging (genre depuis métadonnées)</li>
+<li>API REST (feature <code>server</code>)</li>
+<li>Recommandations (items similaires)</li>
+</ul>
+<hr />
+<h2 id="cas-dusage">🎯 Cas d’usage</h2>
+<h3 id="workflow-typique">Workflow typique</h3>
+<ol type="1">
+<li><strong>Découverte</strong> : Écouter Radio Paradise, tomber sur un
+morceau génial</li>
+<li><strong>Ajout</strong> :
+<code>musicbox.import_from_source(&amp;paradise, "track-123")</code></li>
+<li><strong>Organisation</strong> : Ajouter tags
+<code>mood:chill</code>, <code>occasion:focus</code></li>
+<li><strong>Playlist</strong> : Smart playlist “Focus Music” avec
+requête <code>mood:chill + occasion:focus</code></li>
+<li><strong>Écoute</strong> : Naviguer dans UPnP →
+<code>musicbox/smart-playlists/Focus Music/</code></li>
+</ol>
+<h3 id="scénario-bibliothèque-mixte">Scénario : Bibliothèque mixte</h3>
+<ul>
+<li>Albums Qobuz haute résolution</li>
+<li>Playlists M3U8 importées depuis iTunes</li>
+<li>Fichiers FLAC locaux scannés</li>
+<li>URLs de SoundCloud</li>
+<li>Tracks Radio Paradise capturés</li>
+</ul>
+<p><strong>Tout unifié dans MusicBox, accessible via UPnP, organisé par
+tags.</strong></p>
+<hr />
+<h2 id="références">📚 Références</h2>
+<h3 id="standards">Standards</h3>
+<ul>
+<li><a href="https://www.xspf.org/jspf">JSPF Spec</a></li>
+<li><a href="https://www.xspf.org/spec">XSPF Spec</a></li>
+<li><a href="https://www.sqlite.org/fts5.html">SQLite FTS5</a></li>
+</ul>
+<h3 id="inspirations">Inspirations</h3>
+<ul>
+<li><a href="https://beets.io/">Beets</a> - Music library manager</li>
+<li><a href="https://www.navidrome.org/">Navidrome</a> - Music
+server</li>
+<li><a href="https://picard.musicbrainz.org/">MusicBrainz Picard</a> -
+Tagger</li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/ToThinkAbout_PlayListSource.html

@@ -0,0 +1,539 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>PlayListSource</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<p><strong>Il faut suivre les instructions générales placées dans le
+fichier : Blackboard/Rules.md</strong></p>
+<h1 id="playlistsource-musicsource-pour-playlists">PlaylistSource :
+MusicSource pour playlists</h1>
+<p>Implémenter une source PMOMusic capable de servir un catalogue de
+playlists hiérarchisé via UPnP.</p>
+<hr />
+<h2 id="décisions-de-conception">📋 Décisions de conception</h2>
+<h3 id="format-pivot-jspf-json">Format pivot : JSPF (JSON)</h3>
+<p><strong>Choix</strong> : JSPF comme format interne central -
+Métadonnées riches (title, creator, album, annotation, image, duration,
+etc.) - JSON natif avec serde (Rust-friendly) - Standard ouvert
+(Xiph.Org) - Extensible via champ <code>meta</code></p>
+<p><strong>Formats supportés</strong> : - ✅ <strong>JSPF</strong>
+(.jspf) - JSON, format natif - ✅ <strong>XSPF</strong> (.xspf) - XML,
+conversion vers JSPF - ✅ <strong>M3U8</strong> (.m3u8) - Texte,
+métadonnées limitées - ✅ <strong>PLS</strong> (.pls) - INI-like, très
+basique</p>
+<p><strong>Architecture</strong> : 1 Writer (JSPF) + 4 Readers (JSPF,
+XSPF, M3U8, PLS) → Structure JSPF centrale</p>
+<pre class="mermaid">flowchart LR
+    JSPF[JSPF JSON] --&gt; JR[JspfReader]
+    XSPF[XSPF XML] --&gt; XR[XspfReader]
+    M3U8[M3U8 Text] --&gt; MR[M3uReader]
+    PLS[PLS INI] --&gt; PR[PlsReader]
+    
+    JR --&gt; CORE[JSPF Structure]
+    XR --&gt; CORE
+    MR --&gt; CORE
+    PR --&gt; CORE
+    
+    CORE --&gt; W[JspfWriter]
+    W --&gt; OUT[.jspf]</pre>
+<hr />
+<h2 id="structure-du-répertoire">🗂️ Structure du répertoire</h2>
+<pre><code>playlists/
+├── metadata.json              # Métadonnées du conteneur racine
+├── Jazz/
+│   ├── metadata.json          # Métadonnées catégorie Jazz
+│   ├── standards.jspf
+│   ├── bebop.jspf
+│   └── covers/
+│       └── standards.webp
+├── Classical/
+│   ├── metadata.json
+│   ├── baroque.jspf
+│   └── romantic.jspf
+└── Rock/
+    ├── metadata.json
+    └── 70s.jspf</pre>
+<h3 id="fichier-metadata.json-conteneur">Fichier
+<code>metadata.json</code> (conteneur)</h3>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode json"><code class="sourceCode json"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="fu">{</span></span>
+<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">&quot;container&quot;</span><span class="fu">:</span> <span class="fu">{</span></span>
+<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a>    <span class="dt">&quot;title&quot;</span><span class="fu">:</span> <span class="st">&quot;Collection Jazz&quot;</span><span class="fu">,</span></span>
+<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a>    <span class="dt">&quot;description&quot;</span><span class="fu">:</span> <span class="st">&quot;Mes playlists jazz favorites&quot;</span><span class="fu">,</span></span>
+<span id="cb3-5"><a href="#cb3-5" aria-hidden="true" tabindex="-1"></a>    <span class="dt">&quot;creator&quot;</span><span class="fu">:</span> <span class="st">&quot;John Doe&quot;</span><span class="fu">,</span></span>
+<span id="cb3-6"><a href="#cb3-6" aria-hidden="true" tabindex="-1"></a>    <span class="dt">&quot;image&quot;</span><span class="fu">:</span> <span class="st">&quot;covers/jazz-collection.webp&quot;</span><span class="fu">,</span></span>
+<span id="cb3-7"><a href="#cb3-7" aria-hidden="true" tabindex="-1"></a>    <span class="dt">&quot;date&quot;</span><span class="fu">:</span> <span class="st">&quot;2026-01-15&quot;</span><span class="fu">,</span></span>
+<span id="cb3-8"><a href="#cb3-8" aria-hidden="true" tabindex="-1"></a>    <span class="dt">&quot;meta&quot;</span><span class="fu">:</span> <span class="ot">[</span></span>
+<span id="cb3-9"><a href="#cb3-9" aria-hidden="true" tabindex="-1"></a>      <span class="fu">{</span><span class="dt">&quot;rel&quot;</span><span class="fu">:</span> <span class="st">&quot;genre&quot;</span><span class="fu">,</span> <span class="dt">&quot;content&quot;</span><span class="fu">:</span> <span class="st">&quot;Jazz&quot;</span><span class="fu">}</span><span class="ot">,</span></span>
+<span id="cb3-10"><a href="#cb3-10" aria-hidden="true" tabindex="-1"></a>      <span class="fu">{</span><span class="dt">&quot;rel&quot;</span><span class="fu">:</span> <span class="st">&quot;mood&quot;</span><span class="fu">,</span> <span class="dt">&quot;content&quot;</span><span class="fu">:</span> <span class="st">&quot;Relaxing&quot;</span><span class="fu">}</span></span>
+<span id="cb3-11"><a href="#cb3-11" aria-hidden="true" tabindex="-1"></a>    <span class="ot">]</span></span>
+<span id="cb3-12"><a href="#cb3-12" aria-hidden="true" tabindex="-1"></a>  <span class="fu">}</span></span>
+<span id="cb3-13"><a href="#cb3-13" aria-hidden="true" tabindex="-1"></a><span class="fu">}</span></span></pre></div>
+<hr />
+<h2 id="composants-à-implémenter">🏗️ Composants à implémenter</h2>
+<h3 id="crate-pmojspf-parsing-playlists">1. Crate <code>pmojspf</code>
+(parsing playlists)</h3>
+<p><strong>Responsabilité</strong> : Parser différents formats de
+playlist vers structure JSPF unifiée</p>
+<h4 id="structure">Structure</h4>
+<pre><code>pmojspf/
+├── Cargo.toml
+├── src/
+│   ├── lib.rs           # API publique
+│   ├── model.rs         # Structures JSPF
+│   ├── writer.rs        # JspfWriter
+│   ├── reader/
+│   │   ├── mod.rs       # Trait PlaylistReader
+│   │   ├── jspf.rs      # Reader JSON natif (serde_json)
+│   │   ├── xspf.rs      # Reader XML (xml-rs)
+│   │   ├── m3u.rs       # Reader M3U8 (parsing ligne par ligne)
+│   │   └── pls.rs       # Reader PLS (format INI-like)
+│   └── error.rs
+└── tests/
+    └── fixtures/</pre>
+<h4 id="modèle-de-données">Modèle de données</h4>
+<p><strong>Inspiré de la crate <a
+href="https://crates.io/crates/xspf">xspf</a> v0.4.2</strong></p>
+<div class="sourceCode" id="cb5"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">serde::</span><span class="op">{</span>Deserialize<span class="op">,</span> Serialize<span class="op">};</span></span>
+<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> Deserialize<span class="at">)]</span></span>
+<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> Jspf <span class="op">{</span></span>
+<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> playlist<span class="op">:</span> JspfPlaylist<span class="op">,</span></span>
+<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> Deserialize<span class="op">,</span> <span class="bu">Default</span><span class="at">)]</span></span>
+<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>serde<span class="at">(</span>rename_all <span class="op">=</span> <span class="st">&quot;camelCase&quot;</span><span class="at">)]</span></span>
+<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> JspfPlaylist <span class="op">{</span></span>
+<span id="cb5-11"><a href="#cb5-11" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-12"><a href="#cb5-12" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> title<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-13"><a href="#cb5-13" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-14"><a href="#cb5-14" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> creator<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-15"><a href="#cb5-15" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-16"><a href="#cb5-16" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> annotation<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-17"><a href="#cb5-17" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-18"><a href="#cb5-18" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> info<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-19"><a href="#cb5-19" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-20"><a href="#cb5-20" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> location<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-21"><a href="#cb5-21" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-22"><a href="#cb5-22" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> identifier<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-23"><a href="#cb5-23" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-24"><a href="#cb5-24" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> image<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-25"><a href="#cb5-25" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-26"><a href="#cb5-26" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> date<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-27"><a href="#cb5-27" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-28"><a href="#cb5-28" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> license<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-29"><a href="#cb5-29" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Vec::is_empty&quot;</span><span class="op">,</span> <span class="kw">default</span><span class="at">)]</span></span>
+<span id="cb5-30"><a href="#cb5-30" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> attribution<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>JspfAttribution<span class="op">&gt;,</span></span>
+<span id="cb5-31"><a href="#cb5-31" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Vec::is_empty&quot;</span><span class="op">,</span> <span class="kw">default</span><span class="at">)]</span></span>
+<span id="cb5-32"><a href="#cb5-32" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> meta<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>JspfMeta<span class="op">&gt;,</span></span>
+<span id="cb5-33"><a href="#cb5-33" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span><span class="kw">default</span><span class="at">)]</span></span>
+<span id="cb5-34"><a href="#cb5-34" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> track<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>JspfTrack<span class="op">&gt;,</span></span>
+<span id="cb5-35"><a href="#cb5-35" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb5-36"><a href="#cb5-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-37"><a href="#cb5-37" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> Deserialize<span class="op">,</span> <span class="bu">Default</span><span class="at">)]</span></span>
+<span id="cb5-38"><a href="#cb5-38" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>serde<span class="at">(</span>rename_all <span class="op">=</span> <span class="st">&quot;camelCase&quot;</span><span class="at">)]</span></span>
+<span id="cb5-39"><a href="#cb5-39" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> JspfTrack <span class="op">{</span></span>
+<span id="cb5-40"><a href="#cb5-40" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Vec::is_empty&quot;</span><span class="op">,</span> <span class="kw">default</span><span class="at">)]</span></span>
+<span id="cb5-41"><a href="#cb5-41" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> location<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-42"><a href="#cb5-42" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Vec::is_empty&quot;</span><span class="op">,</span> <span class="kw">default</span><span class="at">)]</span></span>
+<span id="cb5-43"><a href="#cb5-43" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> identifier<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-44"><a href="#cb5-44" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-45"><a href="#cb5-45" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> title<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-46"><a href="#cb5-46" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-47"><a href="#cb5-47" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> creator<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-48"><a href="#cb5-48" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-49"><a href="#cb5-49" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> annotation<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-50"><a href="#cb5-50" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-51"><a href="#cb5-51" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> info<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-52"><a href="#cb5-52" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-53"><a href="#cb5-53" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> image<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-54"><a href="#cb5-54" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-55"><a href="#cb5-55" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> album<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb5-56"><a href="#cb5-56" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-57"><a href="#cb5-57" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> track_num<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;,</span></span>
+<span id="cb5-58"><a href="#cb5-58" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Option::is_none&quot;</span><span class="at">)]</span></span>
+<span id="cb5-59"><a href="#cb5-59" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> duration<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">u64</span><span class="op">&gt;,</span>  <span class="co">// millisecondes</span></span>
+<span id="cb5-60"><a href="#cb5-60" aria-hidden="true" tabindex="-1"></a>    <span class="at">#[</span>serde<span class="at">(</span>skip_serializing_if <span class="op">=</span> <span class="st">&quot;Vec::is_empty&quot;</span><span class="op">,</span> <span class="kw">default</span><span class="at">)]</span></span>
+<span id="cb5-61"><a href="#cb5-61" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> meta<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>JspfMeta<span class="op">&gt;,</span></span>
+<span id="cb5-62"><a href="#cb5-62" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb5-63"><a href="#cb5-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-64"><a href="#cb5-64" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> Deserialize<span class="at">)]</span></span>
+<span id="cb5-65"><a href="#cb5-65" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>serde<span class="at">(</span>untagged<span class="at">)]</span></span>
+<span id="cb5-66"><a href="#cb5-66" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">enum</span> JspfAttribution <span class="op">{</span></span>
+<span id="cb5-67"><a href="#cb5-67" aria-hidden="true" tabindex="-1"></a>    Location <span class="op">{</span> location<span class="op">:</span> <span class="dt">String</span> <span class="op">},</span></span>
+<span id="cb5-68"><a href="#cb5-68" aria-hidden="true" tabindex="-1"></a>    Identifier <span class="op">{</span> identifier<span class="op">:</span> <span class="dt">String</span> <span class="op">},</span></span>
+<span id="cb5-69"><a href="#cb5-69" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb5-70"><a href="#cb5-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-71"><a href="#cb5-71" aria-hidden="true" tabindex="-1"></a><span class="at">#[</span>derive<span class="at">(</span><span class="bu">Debug</span><span class="op">,</span> <span class="bu">Clone</span><span class="op">,</span> Serialize<span class="op">,</span> Deserialize<span class="at">)]</span></span>
+<span id="cb5-72"><a href="#cb5-72" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> JspfMeta <span class="op">{</span></span>
+<span id="cb5-73"><a href="#cb5-73" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> rel<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb5-74"><a href="#cb5-74" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> content<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb5-75"><a href="#cb5-75" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h4 id="trait-playlistreader">Trait PlaylistReader</h4>
+<div class="sourceCode" id="cb6"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">std::io::</span><span class="bu">Read</span><span class="op">;</span></span>
+<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">trait</span> PlaylistReader <span class="op">{</span></span>
+<span id="cb6-4"><a href="#cb6-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> read<span class="op">&lt;</span>R<span class="op">:</span> <span class="bu">Read</span><span class="op">&gt;</span>(reader<span class="op">:</span> R) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;;</span></span>
+<span id="cb6-5"><a href="#cb6-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> from_str(s<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;;</span></span>
+<span id="cb6-6"><a href="#cb6-6" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> from_file<span class="op">&lt;</span>P<span class="op">:</span> <span class="bu">AsRef</span><span class="op">&lt;</span><span class="dt">Path</span><span class="op">&gt;&gt;</span>(path<span class="op">:</span> P) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;;</span></span>
+<span id="cb6-7"><a href="#cb6-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h4 id="implémentations-des-readers">Implémentations des Readers</h4>
+<h5 id="jspfreader-simple---serde_json">JspfReader (✅ Simple -
+serde_json)</h5>
+<div class="sourceCode" id="cb7"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> JspfReader<span class="op">;</span></span>
+<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> PlaylistReader <span class="cf">for</span> JspfReader <span class="op">{</span></span>
+<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> read<span class="op">&lt;</span>R<span class="op">:</span> <span class="bu">Read</span><span class="op">&gt;</span>(reader<span class="op">:</span> R) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a>        <span class="pp">serde_json::</span>from_reader(reader)</span>
+<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>map_err(<span class="op">|</span>e<span class="op">|</span> <span class="bu">Error</span><span class="pp">::</span>ParseError(<span class="pp">format!</span>(<span class="st">&quot;JSON: {}&quot;</span><span class="op">,</span> e)))</span>
+<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Dépendances</strong> : <code>serde_json</code></p>
+<h5 id="xspfreader-complexe---xml-rs">XspfReader (⚠️ Complexe -
+xml-rs)</h5>
+<p><strong>Approche</strong> : Machine à états XML pour parser
+<code>&lt;playlist&gt;</code>, <code>&lt;track&gt;</code>, etc.</p>
+<p><strong>Alternative</strong> : Utiliser la crate <code>xspf</code>
+existante puis convertir → JSPF</p>
+<div class="sourceCode" id="cb8"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> XspfReader<span class="op">;</span></span>
+<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> PlaylistReader <span class="cf">for</span> XspfReader <span class="op">{</span></span>
+<span id="cb8-4"><a href="#cb8-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> read<span class="op">&lt;</span>R<span class="op">:</span> <span class="bu">Read</span><span class="op">&gt;</span>(reader<span class="op">:</span> R) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Parser XML avec EventReader</span></span>
+<span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a>        <span class="co">// État : in_playlist, in_track, current_element</span></span>
+<span id="cb8-7"><a href="#cb8-7" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Mapping: &lt;title&gt; → playlist.title, &lt;track&gt; → JspfTrack</span></span>
+<span id="cb8-8"><a href="#cb8-8" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb8-9"><a href="#cb8-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Dépendances</strong> : <code>xml-rs</code> ou réutiliser
+<code>xspf</code> crate</p>
+<h5 id="m3ureader-modéré---ligne-par-ligne">M3uReader (⚙️ Modéré - ligne
+par ligne)</h5>
+<p><strong>Format</strong> :</p>
+<pre class="m3u"><code>#EXTM3U
+#PLAYLIST:Ma Playlist Jazz
+#EXTINF:284,John Coltrane - Giant Steps
+#EXTART:John Coltrane
+#EXTALB:Giant Steps
+file:///music/coltrane.flac</pre>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> M3uReader<span class="op">;</span></span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> PlaylistReader <span class="cf">for</span> M3uReader <span class="op">{</span></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> read<span class="op">&lt;</span>R<span class="op">:</span> <span class="bu">Read</span><span class="op">&gt;</span>(reader<span class="op">:</span> R) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a>        <span class="co">// BufReader ligne par ligne</span></span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Parser #EXTINF:duration,artist - title</span></span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Gérer extensions non-standard (#EXTART, #EXTALB, #EXTIMG)</span></span>
+<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Dépendances</strong> : stdlib uniquement</p>
+<p><strong>Limitations</strong> : Métadonnées pauvres, beaucoup de
+champs <code>None</code></p>
+<h5 id="plsreader-modéré---format-ini">PlsReader (⚙️ Modéré - format
+INI)</h5>
+<p><strong>Format</strong> :</p>
+<div class="sourceCode" id="cb11"><pre
+class="sourceCode ini"><code class="sourceCode ini"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="kw">[playlist]</span></span>
+<span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a><span class="dt">NumberOfEntries</span><span class="ot">=</span><span class="dv">2</span></span>
+<span id="cb11-3"><a href="#cb11-3" aria-hidden="true" tabindex="-1"></a><span class="dt">File1</span><span class="ot">=</span><span class="st">file:///music/coltrane.flac</span></span>
+<span id="cb11-4"><a href="#cb11-4" aria-hidden="true" tabindex="-1"></a><span class="dt">Title1</span><span class="ot">=</span><span class="st">John Coltrane - Giant Steps</span></span>
+<span id="cb11-5"><a href="#cb11-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Length1</span><span class="ot">=</span><span class="dv">284</span></span></pre></div>
+<div class="sourceCode" id="cb12"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> PlsReader<span class="op">;</span></span>
+<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> PlaylistReader <span class="cf">for</span> PlsReader <span class="op">{</span></span>
+<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> read<span class="op">&lt;</span>R<span class="op">:</span> <span class="bu">Read</span><span class="op">&gt;</span>(reader<span class="op">:</span> R) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a>        <span class="co">// HashMap&lt;index, (file, title, duration)&gt;</span></span>
+<span id="cb12-6"><a href="#cb12-6" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Parser FileN=..., TitleN=..., LengthN=...</span></span>
+<span id="cb12-7"><a href="#cb12-7" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Trier par index et convertir en JspfTrack</span></span>
+<span id="cb12-8"><a href="#cb12-8" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb12-9"><a href="#cb12-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Dépendances</strong> : stdlib uniquement</p>
+<p><strong>Limitations</strong> : File, Title, Length seulement</p>
+<h4 id="jspfwriter">JspfWriter</h4>
+<div class="sourceCode" id="cb13"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> JspfWriter<span class="op">;</span></span>
+<span id="cb13-2"><a href="#cb13-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb13-3"><a href="#cb13-3" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> JspfWriter <span class="op">{</span></span>
+<span id="cb13-4"><a href="#cb13-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> write<span class="op">&lt;</span>W<span class="op">:</span> <span class="bu">Write</span><span class="op">&gt;</span>(jspf<span class="op">:</span> <span class="op">&amp;</span>Jspf<span class="op">,</span> writer<span class="op">:</span> W) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;;</span></span>
+<span id="cb13-5"><a href="#cb13-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> write_pretty<span class="op">&lt;</span>W<span class="op">:</span> <span class="bu">Write</span><span class="op">&gt;</span>(jspf<span class="op">:</span> <span class="op">&amp;</span>Jspf<span class="op">,</span> writer<span class="op">:</span> W) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;;</span></span>
+<span id="cb13-6"><a href="#cb13-6" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> to_string(jspf<span class="op">:</span> <span class="op">&amp;</span>Jspf) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;;</span></span>
+<span id="cb13-7"><a href="#cb13-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> to_string_pretty(jspf<span class="op">:</span> <span class="op">&amp;</span>Jspf) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;;</span></span>
+<span id="cb13-8"><a href="#cb13-8" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h4 id="api-publique">API publique</h4>
+<div class="sourceCode" id="cb14"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">use</span> <span class="pp">model::</span><span class="op">{</span>Jspf<span class="op">,</span> JspfPlaylist<span class="op">,</span> JspfTrack<span class="op">,</span> JspfMeta<span class="op">,</span> JspfAttribution<span class="op">};</span></span>
+<span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">use</span> <span class="pp">reader::</span><span class="op">{</span>PlaylistReader<span class="op">,</span> JspfReader<span class="op">,</span> XspfReader<span class="op">,</span> M3uReader<span class="op">,</span> PlsReader<span class="op">};</span></span>
+<span id="cb14-3"><a href="#cb14-3" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">use</span> <span class="pp">writer::</span>JspfWriter<span class="op">;</span></span>
+<span id="cb14-4"><a href="#cb14-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-5"><a href="#cb14-5" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">enum</span> PlaylistFormat <span class="op">{</span></span>
+<span id="cb14-6"><a href="#cb14-6" aria-hidden="true" tabindex="-1"></a>    Jspf<span class="op">,</span></span>
+<span id="cb14-7"><a href="#cb14-7" aria-hidden="true" tabindex="-1"></a>    Xspf<span class="op">,</span></span>
+<span id="cb14-8"><a href="#cb14-8" aria-hidden="true" tabindex="-1"></a>    M3u8<span class="op">,</span></span>
+<span id="cb14-9"><a href="#cb14-9" aria-hidden="true" tabindex="-1"></a>    Pls<span class="op">,</span></span>
+<span id="cb14-10"><a href="#cb14-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb14-11"><a href="#cb14-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-12"><a href="#cb14-12" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> PlaylistFormat <span class="op">{</span></span>
+<span id="cb14-13"><a href="#cb14-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> <span class="kw">fn</span> from_extension(ext<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span>) <span class="op">-&gt;</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">Self</span><span class="op">&gt;;</span></span>
+<span id="cb14-14"><a href="#cb14-14" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb14-15"><a href="#cb14-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-16"><a href="#cb14-16" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">fn</span> read_playlist<span class="op">&lt;</span>R<span class="op">:</span> <span class="bu">Read</span><span class="op">&gt;</span>(reader<span class="op">:</span> R<span class="op">,</span> format<span class="op">:</span> PlaylistFormat) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>Jspf<span class="op">&gt;;</span></span></pre></div>
+<hr />
+<h3 id="crate-pmoplaylists-playlistsource">2. Crate
+<code>pmoplaylists</code> (PlaylistSource)</h3>
+<p><strong>Responsabilité</strong> : Implémenter
+<code>MusicSource</code> pour servir playlists via UPnP</p>
+<h4 id="structures-principales">Structures principales</h4>
+<div class="sourceCode" id="cb15"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> PlaylistSource <span class="op">{</span></span>
+<span id="cb15-2"><a href="#cb15-2" aria-hidden="true" tabindex="-1"></a>    root_path<span class="op">:</span> <span class="dt">PathBuf</span><span class="op">,</span></span>
+<span id="cb15-3"><a href="#cb15-3" aria-hidden="true" tabindex="-1"></a>    playlists<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span>HashMap<span class="op">&lt;</span><span class="dt">String</span><span class="op">,</span> ParsedPlaylist<span class="op">&gt;&gt;&gt;,</span></span>
+<span id="cb15-4"><a href="#cb15-4" aria-hidden="true" tabindex="-1"></a>    containers<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span>HashMap<span class="op">&lt;</span><span class="dt">PathBuf</span><span class="op">,</span> ContainerMetadata<span class="op">&gt;&gt;&gt;,</span></span>
+<span id="cb15-5"><a href="#cb15-5" aria-hidden="true" tabindex="-1"></a>    watcher<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="pp">notify::</span>RecommendedWatcher<span class="op">&gt;,</span></span>
+<span id="cb15-6"><a href="#cb15-6" aria-hidden="true" tabindex="-1"></a>    base_url<span class="op">:</span> <span class="dt">String</span><span class="op">,</span></span>
+<span id="cb15-7"><a href="#cb15-7" aria-hidden="true" tabindex="-1"></a>    update_counter<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span><span class="dt">u32</span><span class="op">&gt;&gt;,</span></span>
+<span id="cb15-8"><a href="#cb15-8" aria-hidden="true" tabindex="-1"></a>    last_change<span class="op">:</span> Arc<span class="op">&lt;</span>RwLock<span class="op">&lt;</span>SystemTime<span class="op">&gt;&gt;,</span></span>
+<span id="cb15-9"><a href="#cb15-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb15-10"><a href="#cb15-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-11"><a href="#cb15-11" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ParsedPlaylist <span class="op">{</span></span>
+<span id="cb15-12"><a href="#cb15-12" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> metadata<span class="op">:</span> PlaylistMetadata<span class="op">,</span></span>
+<span id="cb15-13"><a href="#cb15-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> tracks<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>PlaylistTrack<span class="op">&gt;,</span></span>
+<span id="cb15-14"><a href="#cb15-14" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> source_path<span class="op">:</span> <span class="dt">PathBuf</span><span class="op">,</span></span>
+<span id="cb15-15"><a href="#cb15-15" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> format<span class="op">:</span> PlaylistFormat<span class="op">,</span></span>
+<span id="cb15-16"><a href="#cb15-16" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb15-17"><a href="#cb15-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-18"><a href="#cb15-18" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ContainerMetadata <span class="op">{</span></span>
+<span id="cb15-19"><a href="#cb15-19" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> title<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb15-20"><a href="#cb15-20" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> description<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb15-21"><a href="#cb15-21" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> creator<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb15-22"><a href="#cb15-22" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> image<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb15-23"><a href="#cb15-23" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> date<span class="op">:</span> <span class="dt">Option</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;,</span></span>
+<span id="cb15-24"><a href="#cb15-24" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> meta<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span>MetaEntry<span class="op">&gt;,</span></span>
+<span id="cb15-25"><a href="#cb15-25" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb15-26"><a href="#cb15-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb15-27"><a href="#cb15-27" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">struct</span> ContainerMetadataFile <span class="op">{</span></span>
+<span id="cb15-28"><a href="#cb15-28" aria-hidden="true" tabindex="-1"></a>    <span class="kw">pub</span> container<span class="op">:</span> ContainerMetadata<span class="op">,</span></span>
+<span id="cb15-29"><a href="#cb15-29" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<h4 id="fonctionnalités">Fonctionnalités</h4>
+<ol type="1">
+<li><strong>Scan hiérarchique</strong> : Parser récursivement dossiers +
+<code>metadata.json</code> + playlists</li>
+<li><strong>Cache</strong> : Éviter re-parsing (playlists +
+conteneurs)</li>
+<li><strong>Hot reload</strong> : <code>notify</code> pour détecter
+changements</li>
+<li><strong>Browse UPnP</strong> : Générer DIDL-Lite avec métadonnées
+conteneurs</li>
+<li><strong>Content resolution</strong> : Résoudre URIs via
+<code>SourceCacheManager</code></li>
+<li><strong>Cover art</strong> : Servir images playlists, tracks,
+conteneurs</li>
+</ol>
+<h4 id="object-ids">Object IDs</h4>
+<pre><code>playlists                                # Racine
+playlists:category:{path}                # Catégorie (dossier)
+playlists:playlist:{id}                  # Playlist
+playlists:playlist:{id}:track:{index}    # Track dans playlist</pre>
+<h4 id="gestion-metadata.json">Gestion <code>metadata.json</code></h4>
+<div class="sourceCode" id="cb17"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a><span class="kw">fn</span> load_container_metadata(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> dir_path<span class="op">:</span> <span class="op">&amp;</span><span class="dt">Path</span>) <span class="op">-&gt;</span> <span class="dt">Result</span><span class="op">&lt;</span>ContainerMetadata<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb17-2"><a href="#cb17-2" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> metadata_path <span class="op">=</span> dir_path<span class="op">.</span>join(<span class="st">&quot;metadata.json&quot;</span>)<span class="op">;</span></span>
+<span id="cb17-3"><a href="#cb17-3" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb17-4"><a href="#cb17-4" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> metadata_path<span class="op">.</span>exists() <span class="op">{</span></span>
+<span id="cb17-5"><a href="#cb17-5" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> content <span class="op">=</span> <span class="pp">fs::</span>read_to_string(<span class="op">&amp;</span>metadata_path)<span class="op">?;</span></span>
+<span id="cb17-6"><a href="#cb17-6" aria-hidden="true" tabindex="-1"></a>        <span class="kw">let</span> file<span class="op">:</span> ContainerMetadataFile <span class="op">=</span> <span class="pp">serde_json::</span>from_str(<span class="op">&amp;</span>content)<span class="op">?;</span></span>
+<span id="cb17-7"><a href="#cb17-7" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(file<span class="op">.</span>container)</span>
+<span id="cb17-8"><a href="#cb17-8" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb17-9"><a href="#cb17-9" aria-hidden="true" tabindex="-1"></a>        <span class="co">// Fallback : nom du répertoire</span></span>
+<span id="cb17-10"><a href="#cb17-10" aria-hidden="true" tabindex="-1"></a>        <span class="cn">Ok</span>(ContainerMetadata <span class="op">{</span></span>
+<span id="cb17-11"><a href="#cb17-11" aria-hidden="true" tabindex="-1"></a>            title<span class="op">:</span> <span class="cn">Some</span>(dir_path<span class="op">.</span>file_name()<span class="op">?.</span>to_str()<span class="op">?.</span>to_string())<span class="op">,</span></span>
+<span id="cb17-12"><a href="#cb17-12" aria-hidden="true" tabindex="-1"></a>            <span class="op">..</span><span class="bu">Default</span><span class="pp">::</span><span class="kw">default</span>()</span>
+<span id="cb17-13"><a href="#cb17-13" aria-hidden="true" tabindex="-1"></a>        <span class="op">}</span>)</span>
+<span id="cb17-14"><a href="#cb17-14" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb17-15"><a href="#cb17-15" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<hr />
+<h3 id="extension-pmoconfig">3. Extension pmoconfig</h3>
+<p><strong>Fichier</strong> :
+<code>pmoplaylists/src/config_ext.rs</code></p>
+<p><strong>Pattern</strong> : <a
+href="../Architecture/pmoconfig_ext.md">pmoconfig_ext.md</a></p>
+<div class="sourceCode" id="cb18"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb18-1"><a href="#cb18-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmoconfig::</span>Config<span class="op">;</span></span>
+<span id="cb18-2"><a href="#cb18-2" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">std::path::</span><span class="op">{</span><span class="dt">Path</span><span class="op">,</span> <span class="dt">PathBuf</span><span class="op">};</span></span>
+<span id="cb18-3"><a href="#cb18-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb18-4"><a href="#cb18-4" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> DEFAULT_PLAYLISTS_DIR<span class="op">:</span> <span class="op">&amp;</span><span class="dt">str</span> <span class="op">=</span> <span class="st">&quot;playlists&quot;</span><span class="op">;</span></span>
+<span id="cb18-5"><a href="#cb18-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb18-6"><a href="#cb18-6" aria-hidden="true" tabindex="-1"></a><span class="kw">pub</span> <span class="kw">trait</span> PlaylistSourceConfigExt <span class="op">{</span></span>
+<span id="cb18-7"><a href="#cb18-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> get_playlists_dir(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">PathBuf</span><span class="op">;</span></span>
+<span id="cb18-8"><a href="#cb18-8" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> set_playlists_dir<span class="op">&lt;</span>P<span class="op">:</span> <span class="bu">AsRef</span><span class="op">&lt;</span><span class="dt">Path</span><span class="op">&gt;&gt;</span>(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> path<span class="op">:</span> P) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;;</span></span>
+<span id="cb18-9"><a href="#cb18-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> get_playlists_enabled(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">bool</span><span class="op">;</span></span>
+<span id="cb18-10"><a href="#cb18-10" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> set_playlists_enabled(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> enabled<span class="op">:</span> <span class="dt">bool</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;;</span></span>
+<span id="cb18-11"><a href="#cb18-11" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> get_playlists_supported_formats(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;;</span></span>
+<span id="cb18-12"><a href="#cb18-12" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> set_playlists_supported_formats(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> formats<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;;</span></span>
+<span id="cb18-13"><a href="#cb18-13" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb18-14"><a href="#cb18-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb18-15"><a href="#cb18-15" aria-hidden="true" tabindex="-1"></a><span class="kw">impl</span> PlaylistSourceConfigExt <span class="cf">for</span> Config <span class="op">{</span></span>
+<span id="cb18-16"><a href="#cb18-16" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> get_playlists_dir(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">PathBuf</span> <span class="op">{</span></span>
+<span id="cb18-17"><a href="#cb18-17" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>get_managed_dir(<span class="st">&quot;sources.playlists.directory&quot;</span><span class="op">,</span> DEFAULT_PLAYLISTS_DIR)</span>
+<span id="cb18-18"><a href="#cb18-18" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>expect(<span class="st">&quot;Failed to get playlists directory&quot;</span>)</span>
+<span id="cb18-19"><a href="#cb18-19" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-20"><a href="#cb18-20" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb18-21"><a href="#cb18-21" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> set_playlists_dir<span class="op">&lt;</span>P<span class="op">:</span> <span class="bu">AsRef</span><span class="op">&lt;</span><span class="dt">Path</span><span class="op">&gt;&gt;</span>(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> path<span class="op">:</span> P) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb18-22"><a href="#cb18-22" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>set_managed_dir(<span class="st">&quot;sources.playlists.directory&quot;</span><span class="op">,</span> path)</span>
+<span id="cb18-23"><a href="#cb18-23" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-24"><a href="#cb18-24" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb18-25"><a href="#cb18-25" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> get_playlists_enabled(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
+<span id="cb18-26"><a href="#cb18-26" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>get_value(<span class="st">&quot;sources.playlists.enabled&quot;</span>)</span>
+<span id="cb18-27"><a href="#cb18-27" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>unwrap_or_else(<span class="op">|</span>_<span class="op">|</span> <span class="op">{</span></span>
+<span id="cb18-28"><a href="#cb18-28" aria-hidden="true" tabindex="-1"></a>                <span class="kw">let</span> _ <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>set_value(<span class="st">&quot;sources.playlists.enabled&quot;</span><span class="op">,</span> <span class="cn">true</span>)<span class="op">;</span></span>
+<span id="cb18-29"><a href="#cb18-29" aria-hidden="true" tabindex="-1"></a>                <span class="cn">true</span></span>
+<span id="cb18-30"><a href="#cb18-30" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span>)</span>
+<span id="cb18-31"><a href="#cb18-31" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-32"><a href="#cb18-32" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb18-33"><a href="#cb18-33" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> set_playlists_enabled(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> enabled<span class="op">:</span> <span class="dt">bool</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb18-34"><a href="#cb18-34" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>set_value(<span class="st">&quot;sources.playlists.enabled&quot;</span><span class="op">,</span> enabled)</span>
+<span id="cb18-35"><a href="#cb18-35" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-36"><a href="#cb18-36" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb18-37"><a href="#cb18-37" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> get_playlists_supported_formats(<span class="op">&amp;</span><span class="kw">self</span>) <span class="op">-&gt;</span> <span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb18-38"><a href="#cb18-38" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>get_value(<span class="st">&quot;sources.playlists.formats&quot;</span>)</span>
+<span id="cb18-39"><a href="#cb18-39" aria-hidden="true" tabindex="-1"></a>            <span class="op">.</span>unwrap_or_else(<span class="op">|</span>_<span class="op">|</span> <span class="op">{</span></span>
+<span id="cb18-40"><a href="#cb18-40" aria-hidden="true" tabindex="-1"></a>                <span class="kw">let</span> <span class="kw">default</span> <span class="op">=</span> <span class="pp">vec!</span>[<span class="st">&quot;jspf&quot;</span><span class="op">.</span>into()<span class="op">,</span> <span class="st">&quot;xspf&quot;</span><span class="op">.</span>into()<span class="op">,</span> <span class="st">&quot;m3u8&quot;</span><span class="op">.</span>into()<span class="op">,</span> <span class="st">&quot;pls&quot;</span><span class="op">.</span>into()]<span class="op">;</span></span>
+<span id="cb18-41"><a href="#cb18-41" aria-hidden="true" tabindex="-1"></a>                <span class="kw">let</span> _ <span class="op">=</span> <span class="kw">self</span><span class="op">.</span>set_value(<span class="st">&quot;sources.playlists.formats&quot;</span><span class="op">,</span> <span class="op">&amp;</span><span class="kw">default</span>)<span class="op">;</span></span>
+<span id="cb18-42"><a href="#cb18-42" aria-hidden="true" tabindex="-1"></a>                <span class="kw">default</span></span>
+<span id="cb18-43"><a href="#cb18-43" aria-hidden="true" tabindex="-1"></a>            <span class="op">}</span>)</span>
+<span id="cb18-44"><a href="#cb18-44" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-45"><a href="#cb18-45" aria-hidden="true" tabindex="-1"></a>    </span>
+<span id="cb18-46"><a href="#cb18-46" aria-hidden="true" tabindex="-1"></a>    <span class="kw">fn</span> set_playlists_supported_formats(<span class="op">&amp;</span><span class="kw">self</span><span class="op">,</span> formats<span class="op">:</span> <span class="dt">Vec</span><span class="op">&lt;</span><span class="dt">String</span><span class="op">&gt;</span>) <span class="op">-&gt;</span> <span class="pp">anyhow::</span><span class="dt">Result</span><span class="op">&lt;</span>()<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb18-47"><a href="#cb18-47" aria-hidden="true" tabindex="-1"></a>        <span class="kw">self</span><span class="op">.</span>set_value(<span class="st">&quot;sources.playlists.formats&quot;</span><span class="op">,</span> formats)</span>
+<span id="cb18-48"><a href="#cb18-48" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
+<span id="cb18-49"><a href="#cb18-49" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<p><strong>Config YAML</strong> :</p>
+<div class="sourceCode" id="cb19"><pre
+class="sourceCode yaml"><code class="sourceCode yaml"><span id="cb19-1"><a href="#cb19-1" aria-hidden="true" tabindex="-1"></a><span class="fu">sources</span><span class="kw">:</span></span>
+<span id="cb19-2"><a href="#cb19-2" aria-hidden="true" tabindex="-1"></a><span class="at">  </span><span class="fu">playlists</span><span class="kw">:</span></span>
+<span id="cb19-3"><a href="#cb19-3" aria-hidden="true" tabindex="-1"></a><span class="at">    </span><span class="fu">enabled</span><span class="kw">:</span><span class="at"> </span><span class="ch">true</span></span>
+<span id="cb19-4"><a href="#cb19-4" aria-hidden="true" tabindex="-1"></a><span class="at">    </span><span class="fu">directory</span><span class="kw">:</span><span class="at"> </span><span class="st">&quot;playlists&quot;</span></span>
+<span id="cb19-5"><a href="#cb19-5" aria-hidden="true" tabindex="-1"></a><span class="at">    </span><span class="fu">formats</span><span class="kw">:</span></span>
+<span id="cb19-6"><a href="#cb19-6" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="kw">-</span><span class="at"> jspf</span></span>
+<span id="cb19-7"><a href="#cb19-7" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="kw">-</span><span class="at"> xspf</span></span>
+<span id="cb19-8"><a href="#cb19-8" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="kw">-</span><span class="at"> m3u8</span></span>
+<span id="cb19-9"><a href="#cb19-9" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="kw">-</span><span class="at"> pls</span></span></pre></div>
+<p><strong>Utilisation</strong> :</p>
+<div class="sourceCode" id="cb20"><pre
+class="sourceCode rust"><code class="sourceCode rust"><span id="cb20-1"><a href="#cb20-1" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmoconfig::</span>Config<span class="op">;</span></span>
+<span id="cb20-2"><a href="#cb20-2" aria-hidden="true" tabindex="-1"></a><span class="kw">use</span> <span class="pp">pmoplaylists::config_ext::</span>PlaylistSourceConfigExt<span class="op">;</span></span>
+<span id="cb20-3"><a href="#cb20-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb20-4"><a href="#cb20-4" aria-hidden="true" tabindex="-1"></a><span class="kw">let</span> config <span class="op">=</span> <span class="pp">Config::</span>load()<span class="op">?;</span></span>
+<span id="cb20-5"><a href="#cb20-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb20-6"><a href="#cb20-6" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> config<span class="op">.</span>get_playlists_enabled() <span class="op">{</span></span>
+<span id="cb20-7"><a href="#cb20-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> playlists_dir <span class="op">=</span> config<span class="op">.</span>get_playlists_dir()<span class="op">;</span></span>
+<span id="cb20-8"><a href="#cb20-8" aria-hidden="true" tabindex="-1"></a>    <span class="kw">let</span> playlist_source <span class="op">=</span> <span class="pp">PlaylistSource::</span>new(playlists_dir<span class="op">,</span> config<span class="op">.</span>clone())<span class="op">?;</span></span>
+<span id="cb20-9"><a href="#cb20-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></pre></div>
+<hr />
+<h2 id="intégration-musicbrainz-optionnelle---phase-2">🔌 Intégration
+MusicBrainz (optionnelle - Phase 2)</h2>
+<h3 id="crate-recommandée-musicbrainz_rs">Crate recommandée :
+<code>musicbrainz_rs</code></h3>
+<p><a href="https://crates.io/crates/musicbrainz_rs">musicbrainz_rs</a>
+v0.5+ - Client async/blocking - Rate limiting automatique (1 req/sec) -
+Support CoverArt Archive - MSRV: Rust 1.71.1</p>
+<h3 id="cas-dusage">Cas d’usage</h3>
+<ol type="1">
+<li><p><strong>Résolution d’identifiants</strong> :</p>
+<div class="sourceCode" id="cb21"><pre
+class="sourceCode json"><code class="sourceCode json"><span id="cb21-1"><a href="#cb21-1" aria-hidden="true" tabindex="-1"></a><span class="fu">{</span><span class="dt">&quot;identifier&quot;</span><span class="fu">:</span> <span class="ot">[</span><span class="st">&quot;musicbrainz://recording/abc123&quot;</span><span class="ot">]</span><span class="fu">,</span> <span class="dt">&quot;title&quot;</span><span class="fu">:</span> <span class="kw">null</span><span class="fu">}</span></span></pre></div>
+<p>→ Récupérer métadonnées depuis MusicBrainz</p></li>
+<li><p><strong>Enrichissement playlists pauvres</strong> : M3U8/PLS →
+MusicBrainz → métadonnées complètes</p></li>
+<li><p><strong>Cover art</strong> : CoverArt Archive</p></li>
+</ol>
+<h3 id="configuration">Configuration</h3>
+<div class="sourceCode" id="cb22"><pre
+class="sourceCode yaml"><code class="sourceCode yaml"><span id="cb22-1"><a href="#cb22-1" aria-hidden="true" tabindex="-1"></a><span class="fu">sources</span><span class="kw">:</span></span>
+<span id="cb22-2"><a href="#cb22-2" aria-hidden="true" tabindex="-1"></a><span class="at">  </span><span class="fu">playlists</span><span class="kw">:</span></span>
+<span id="cb22-3"><a href="#cb22-3" aria-hidden="true" tabindex="-1"></a><span class="at">    </span><span class="fu">musicbrainz</span><span class="kw">:</span></span>
+<span id="cb22-4"><a href="#cb22-4" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="fu">enabled</span><span class="kw">:</span><span class="at"> </span><span class="ch">false</span></span>
+<span id="cb22-5"><a href="#cb22-5" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="fu">enrich_metadata</span><span class="kw">:</span><span class="at"> </span><span class="ch">false</span></span>
+<span id="cb22-6"><a href="#cb22-6" aria-hidden="true" tabindex="-1"></a><span class="at">      </span><span class="fu">rate_limit_per_sec</span><span class="kw">:</span><span class="at"> </span><span class="dv">1</span></span></pre></div>
+<p><strong>Stratégie</strong> : - <strong>Phase 1 (MVP)</strong> : Ne
+pas implémenter, stocker identifiants tel quel - <strong>Phase
+2</strong> : Dépendance optionnelle, service asynchrone,
+configurable</p>
+<hr />
+<h2 id="prochaines-étapes">📝 Prochaines étapes</h2>
+<ol type="1">
+<li>✅ Choix format : JSPF central</li>
+<li>✅ Modèle données : Structures JSPF</li>
+<li>✅ Extension pmoconfig : Trait défini</li>
+<li>⏳ <strong>Implémenter <code>pmojspf</code></strong> :
+<ul>
+<li><code>JspfReader</code> (serde_json)</li>
+<li><code>XspfReader</code> (xml-rs ou crate xspf)</li>
+<li><code>M3uReader</code> (parsing ligne par ligne)</li>
+<li><code>PlsReader</code> (format INI)</li>
+<li><code>JspfWriter</code> (serde_json)</li>
+</ul></li>
+<li>⏳ <strong>Implémenter <code>pmoplaylists</code></strong> :
+<ul>
+<li><code>PlaylistSource</code> (trait <code>MusicSource</code>)</li>
+<li>Scan hiérarchique + cache</li>
+<li>Hot reload (notify)</li>
+<li>Browse UPnP (DIDL-Lite)</li>
+<li>Gestion <code>metadata.json</code></li>
+</ul></li>
+<li>⏳ Tests avec clients UPnP</li>
+</ol>
+<hr />
+<h2 id="sources">📚 Sources</h2>
+<h3 id="spécifications">Spécifications</h3>
+<ul>
+<li><a href="https://www.xspf.org/spec">XSPF Spec</a></li>
+<li><a href="https://www.xspf.org/jspf">JSPF Spec</a></li>
+<li><a href="https://en.wikipedia.org/wiki/M3U">M3U - Wikipedia</a></li>
+<li><a href="https://en.wikipedia.org/wiki/PLS_(file_format)">PLS -
+Wikipedia</a></li>
+</ul>
+<h3 id="crates-rust">Crates Rust</h3>
+<ul>
+<li><a href="https://crates.io/crates/xspf">xspf</a> - Parser XML
+XSPF</li>
+<li><a href="https://crates.io/crates/musicbrainz_rs">musicbrainz_rs</a>
+- API MusicBrainz</li>
+<li><a href="https://musicbrainz.org/doc/MusicBrainz_API">MusicBrainz
+API Docs</a></li>
+</ul>
+</article>
+</body>
+</html>

Blackboard_HTML/Todo_config_ext.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>config_ext</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<p><strong>Il faut suivre les instructions générales placées dans le
+fichier : Blackboard/Rules.md</strong></p>
+<p>Partir des fichiers suivants:</p>
+<ul>
+<li>pmocovers/src/config_ext.rs</li>
+<li>pmoaudiocache/src/config_ext.rs</li>
+<li>pmoqobuz/src/config_ext.rs</li>
+<li>pmocache/src/config_ext.rs</li>
+<li>pmoconfig/PASSWORD_ENCRYPTION.md</li>
+<li>pmoupnp/src/config_ext.rs</li>
+<li>pmoparadise/src/config_ext.rs</li>
+</ul>
+<p>réalise une fiche descriptive sur le pattern à réaliser pour
+implémenter un trait d’extension de PMOConfig (pmoconfig::Config).</p>
+<p>Le résultat sera une documentation d’implémentation qui sera placé
+dans le fichier:
+<code>Blackboard/Architecture/pmoconfig_ext.md</code></p>
+<p>Reste bien focalisé sur l’objectif principal.</p>
+</article>
+</body>
+</html>

Blackboard_HTML/Todo_music_source.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>music_source</title>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown.min.css">
+<script type="module">
+  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs";
+  mermaid.initialize({startOnLoad: true, theme: "default"});
+</script>
+<style>
+  .markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+  }
+  .back-link {
+    margin-bottom: 20px;
+    display: block;
+  }
+  pre.mermaid {
+    background: #fff;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+  }
+</style>
+</head>
+<body>
+<article class="markdown-body">
+<p class="back-link"><a href="index.html">← Retour à l'index</a></p>
+<p><strong>Il faut suivre les instructions générales placées dans le
+fichier : Blackboard/Rules.md</strong></p>
+<p>Partir des fichiers suivants:</p>
+<ul>
+<li>pmoparadise/src/source.rs</li>
+<li>pmoqobuz/src/source.rs</li>
+<li>pmosource/README.md</li>
+<li>pmosource/ARCHITECTURE.md</li>
+</ul>
+<p>D’écrire dans un fichier d’architecture L’implémentation d’une
+nouvelle MusicSource.</p>
+<p>Le résultat sera une documentation d’implémentation qui sera placé
+dans le fichier:
+<code>Blackboard/Architecture/music_source.md</code></p>
+<p>Reste bien focalisé sur l’objectif principal.</p>
+</article>
+</body>
+</html>

Blackboard_HTML/index.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="fr"><head><meta charset="utf-8">
+<title>PMOMusic Blackboard</title>
+<style>
+body{font-family:sans-serif;margin:20px;background:#f5f5f5}
+h1{color:#2c3e50}ul{list-style:none;padding:0}
+li{margin:10px 0}a{color:#3498db;text-decoration:none}
+a:hover{text-decoration:underline}.category{margin-top:30px}
+.category h2{color:#e74c3c;border-bottom:2px solid #e74c3c;padding-bottom:5px}
+</style></head><body>
+<h1>📋 PMOMusic Blackboard</h1>
+<div class='category'><h2>Architecture</h2><ul>
+<li><a href='Architecture_music_source.html'>music_source</a></li>
+<li><a href='Architecture_pmoconfig_ext.html'>pmoconfig_ext</a></li>
+<li><a href='Architecture_pmoserver_ext.html'>pmoserver_ext</a></li>
+</ul></div>
+<div class='category'><h2>ToThinkAbout</h2><ul>
+<li><a href='ToThinkAbout_MusicBoxSource.html'>MusicBoxSource</a></li>
+<li><a href='ToThinkAbout_PlayListSource.html'>PlayListSource</a></li>
+</ul></div>
+<div class='category'><h2>ToDiscuss</h2><ul>
+<li><a href='ToDiscuss_Pinnable_cache_item.html'>Pinnable_cache_item</a></li>
+<li><a href='ToDiscuss_pmoserver_ext.html'>pmoserver_ext</a></li>
+</ul></div>
+<div class='category'><h2>Todo</h2><ul>
+<li><a href='Todo_config_ext.html'>config_ext</a></li>
+<li><a href='Todo_music_source.html'>music_source</a></li>
+</ul></div>
+<div class='category'><h2>Done</h2><ul>
+<li><a href='Done_Pinnable_cache_item.html'>Pinnable_cache_item</a></li>
+<li><a href='Done_WeabApp_debouncingSSE.html'>WeabApp_debouncingSSE</a></li>
+</ul></div>
+<div class='category'><h2>Report</h2><ul>
+<li><a href='Report_Pinnable_cache_item.html'>Pinnable_cache_item</a></li>
+<li><a href='Report_WeabApp_debouncingSSE.html'>WeabApp_debouncingSSE</a></li>
+<li><a href='Report_config_ext.html'>config_ext</a></li>
+<li><a href='Report_music_source.html'>music_source</a></li>
+<li><a href='Report_pmoserver_ext.html'>pmoserver_ext</a></li>
+</ul></div>
+</body></html>

Cargo.toml

@@ -4,9 +4,9 @@ members = [
     "PMOMusic",
     "pmoupnp",
     "pmomediarenderer",
+    "pmowebrenderer",
     "pmomediaserver",
     "pmoconfig",
-    "pmoutils",
     "pmodidl",
     "pmoserver",
     "pmoapp",
@@ -14,12 +14,15 @@ members = [
     "pmocovers",
     "pmoaudiocache",
     "pmoaudio",
+    "pmoaudio-ext",
     "pmoqobuz",
     "pmoparadise",
+    "pmoradiofrance",
     "pmosource",
     "pmoplaylist",
     "pmoflac",
-    "pmometadata", "pmocontrol",
+    "pmometadata",
+    "pmocontrol",
 ]
 
 [workspace.dependencies]
@@ -35,7 +38,7 @@ async-trait = "0.1"
 
 # Error handling
 anyhow = "1.0"
-thiserror = "2.0"  # ⚠️ Unifier sur 2.0 (vous avez 1.0 et 2.0)
+thiserror = "2.0"
 
 # Logging
 tracing = "0.1.41"
@@ -44,12 +47,15 @@ tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
 # HTTP/XML
 reqwest = { version = "0.12", default-features = false }
 ureq = "3.1"
-quick-xml = { version = "0.38", features = ["serialize"] }  # ⚠️ Unifier 0.37→0.38
+quick-xml = { version = "0.38", features = ["serialize"] }
+axum = "0.8.4"
+futures = "0.3"
 
 # Utilities
 chrono = { version = "0.4", features = ["serde"] }
 uuid = { version = "1.18", features = ["v4"] }
 crossbeam-channel = "0.5"
+rand = "0.9"
 
 # Testing
 tokio-test = "0.4"

Dockerfile

@@ -32,8 +32,9 @@ RUN apt-get update && apt-get install -y \
     cmake \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy Cargo workspace files
+# Copy Cargo workspace files and registry configuration
 COPY Cargo.toml Cargo.lock ./
+COPY .cargo/ ./.cargo/
 
 # Copy all crates
 COPY PMOMusic/ ./PMOMusic/
@@ -41,7 +42,6 @@ COPY pmoupnp/ ./pmoupnp/
 COPY pmomediarenderer/ ./pmomediarenderer/
 COPY pmomediaserver/ ./pmomediaserver/
 COPY pmoconfig/ ./pmoconfig/
-COPY pmoutils/ ./pmoutils/
 COPY pmodidl/ ./pmodidl/
 COPY pmoserver/ ./pmoserver/
 COPY pmocache/ ./pmocache/
@@ -50,6 +50,8 @@ COPY pmoaudiocache/ ./pmoaudiocache/
 COPY pmoaudio/ ./pmoaudio/
 COPY pmoqobuz/ ./pmoqobuz/
 COPY pmoparadise/ ./pmoparadise/
+COPY pmoradiofrance/ ./pmoradiofrance/
+COPY pmowebrenderer/ ./pmowebrenderer/
 COPY pmosource/ ./pmosource/
 COPY pmoplaylist/ ./pmoplaylist/
 COPY pmoflac/ ./pmoflac/

Makefile

@@ -13,6 +13,7 @@ BINARY_NAME = PMOMusic
 # Couleurs pour l'affichage
 GREEN = \033[0;32m
 YELLOW = \033[1;33m
+BLUE = \033[1;34m
 RED = \033[0;31m
 NC = \033[0m # No Color
 
@@ -160,15 +161,17 @@ watch:
 ci: fmt-check clippy test doc-build webapp
 	@echo "$(GREEN)✓ Toutes les vérifications CI passées$(NC)"
 
-## run: Lance le binaire en mode debug
+## run: Compile en debug et lance via Terminal.app (requis pour le multicast sur macOS Sequoia+)
 run: debug
-	@echo "$(YELLOW)→ Lancement de l'application...$(NC)"
-	./target/debug/$(BINARY_NAME)
+	@echo "$(YELLOW)→ Lancement de l'application via Terminal.app...$(NC)"
+	@echo "$(BLUE)  (Terminal.app est nécessaire pour le multicast sur macOS Sequoia+)$(NC)"
+	@osascript -e 'tell application "Terminal" to do script "cd \"$(CURDIR)\" && ./target/debug/$(BINARY_NAME) 2>&1 | tee pmomusic.log; exit"'
 
-## run-release: Lance le binaire en mode release
+## run-release: Compile en release et lance via Terminal.app (requis pour le multicast sur macOS Sequoia+)
 run-release: release
-	@echo "$(YELLOW)→ Lancement de l'application (release)...$(NC)"
-	./$(RUST_TARGET)/$(BINARY_NAME)
+	@echo "$(YELLOW)→ Lancement de l'application (release) via Terminal.app...$(NC)"
+	@echo "$(BLUE)  (Terminal.app est nécessaire pour le multicast sur macOS Sequoia+)$(NC)"
+	@osascript -e 'tell application "Terminal" to do script "cd \"$(CURDIR)\" && ./$(RUST_TARGET)/$(BINARY_NAME) 2>&1 | tee pmomusic.log; exit"'
 
 ## size: Affiche la taille du binaire
 size:
@@ -193,6 +196,28 @@ update:
 	cd $(WEBAPP_DIR) && $(NPM) update
 	@echo "$(GREEN)✓ Dépendances mises à jour$(NC)"
 
+## bump-version: Incrémente le numéro de version patch (x.y.z -> x.y.z+1)
+bump-version:
+	@echo "$(YELLOW)→ Incrémentation de la version...$(NC)"
+	@current=$$(grep '^version = ' PMOMusic/Cargo.toml | head -n 1 | sed 's/version = "\(.*\)"/\1/'); \
+	echo "  Version actuelle: $$current"; \
+	major=$$(echo $$current | cut -d. -f1); \
+	minor=$$(echo $$current | cut -d. -f2); \
+	patch=$$(echo $$current | cut -d. -f3); \
+	new_patch=$$((patch + 1)); \
+	new_version="$$major.$$minor.$$new_patch"; \
+	echo "  Nouvelle version: $$new_version"; \
+	sed -i.bak "s/^version = \"$$current\"/version = \"$$new_version\"/" PMOMusic/Cargo.toml && \
+	rm PMOMusic/Cargo.toml.bak && \
+	echo "$$new_version" > version.txt
+	@echo "$(GREEN)✓ Version mise à jour dans PMOMusic/Cargo.toml et version.txt$(NC)"
+
+## sync-version: Synchronise version.txt depuis PMOMusic/Cargo.toml
+version.txt: PMOMusic/Cargo.toml
+	@echo "$(YELLOW)→ Synchronisation de version.txt...$(NC)"
+	@grep '^version = ' PMOMusic/Cargo.toml | head -n 1 | sed 's/version = "\(.*\)"/\1/' > version.txt
+	@echo "$(GREEN)✓ version.txt synchronisé: $$(cat version.txt)$(NC)"
+
 ## bench: Exécute les benchmarks
 bench:
 	@echo "$(YELLOW)→ Exécution des benchmarks...$(NC)"
@@ -203,4 +228,70 @@ coverage:
 	@echo "$(YELLOW)→ Génération du rapport de couverture...$(NC)"
 	$(CARGO) tarpaulin --out Html --output-dir target/coverage
 	@echo "$(GREEN)✓ Rapport disponible dans target/coverage/index.html$(NC)"
-	
+
+jjnew:
+	@echo "$(YELLOW)→ Création d'un nouveau commit...$(NC)"
+	@echo "$(BLUE)→ Documentation du commit courrant...$(NC)"
+	@jj auto-describe
+	@echo "$(BLUE)→ C'est fait.$(NC)"
+	@jj new
+	@echo "$(GREEN)✓ nouveau commit créé$(NC)"
+
+jjpush: bump-version
+	@echo "$(YELLOW)→ Push du commit sur le dépôt...$(NC)"
+	@echo "$(BLUE)→ Documentation du commit courrant...$(NC)"
+	@jj auto-describe
+	@echo "$(BLUE)→ C'est fait.$(NC)"
+	@jj git push --change @
+	@echo "$(GREEN)✓ Commit pushé sur le dépôt$(NC)"
+
+jjfetch:
+	@echo "$(YELLOW)→ Pull des derniers commits...$(NC)"
+	@jj git fetch
+	@jj new main@origin
+	@echo "$(GREEN)✓ Derniers commits pullés$(NC)"
+
+## blackboard-html: Génère les fichiers HTML du Blackboard avec support Mermaid
+blackboard-html:
+	@echo "$(YELLOW)→ Génération des fichiers HTML du Blackboard...$(NC)"
+	@mkdir -p Blackboard_HTML
+	@echo "<!DOCTYPE html>" > Blackboard_HTML/index.html
+	@echo '<html lang="fr"><head><meta charset="utf-8">' >> Blackboard_HTML/index.html
+	@echo "<title>PMOMusic Blackboard</title>" >> Blackboard_HTML/index.html
+	@echo "<style>" >> Blackboard_HTML/index.html
+	@echo "body{font-family:sans-serif;margin:20px;background:#f5f5f5}" >> Blackboard_HTML/index.html
+	@echo "h1{color:#2c3e50}ul{list-style:none;padding:0}" >> Blackboard_HTML/index.html
+	@echo "li{margin:10px 0}a{color:#3498db;text-decoration:none}" >> Blackboard_HTML/index.html
+	@echo "a:hover{text-decoration:underline}.category{margin-top:30px}" >> Blackboard_HTML/index.html
+	@echo ".category h2{color:#e74c3c;border-bottom:2px solid #e74c3c;padding-bottom:5px}" >> Blackboard_HTML/index.html
+	@echo "</style></head><body>" >> Blackboard_HTML/index.html
+	@echo '<h1>📋 PMOMusic Blackboard</h1>' >> Blackboard_HTML/index.html
+	@for category in Architecture ToThinkAbout ToDiscuss Todo Done Report; do \
+		if [ -d "Blackboard/$$category" ]; then \
+			echo "<div class='category'><h2>$$category</h2><ul>" >> Blackboard_HTML/index.html; \
+			find "Blackboard/$$category" -name "*.md" -type f | sort | while read -r file; do \
+				basename=$$(basename "$$file" .md); \
+				relpath=$$(echo "$$file" | sed 's|Blackboard/||'); \
+				htmlfile=$$(echo "$$relpath" | sed 's|/|_|g' | sed 's|\.md$$|.html|'); \
+				echo "<li><a href='$$htmlfile'>$$basename</a></li>" >> Blackboard_HTML/index.html; \
+				echo "  → Conversion: $$relpath → $$htmlfile"; \
+				/opt/homebrew/bin/pandoc "$$file" -o "Blackboard_HTML/$$htmlfile" \
+					--standalone \
+					--template=blackboard-template.html \
+					--metadata title="$$basename" \
+					--from markdown \
+					--to html; \
+				./fix-mermaid.sh "Blackboard_HTML/$$htmlfile"; \
+			done; \
+			echo "</ul></div>" >> Blackboard_HTML/index.html; \
+		fi; \
+	done
+	@echo "</body></html>" >> Blackboard_HTML/index.html
+	@echo "$(GREEN)✓ Fichiers HTML générés dans Blackboard_HTML/$(NC)"
+	@echo "$(BLUE)  Ouvrir: open Blackboard_HTML/index.html$(NC)"
+
+## blackboard-clean: Nettoie les fichiers HTML générés
+blackboard-clean:
+	@echo "$(YELLOW)→ Nettoyage des fichiers HTML du Blackboard...$(NC)"
+	@rm -rf Blackboard_HTML
+	@echo "$(GREEN)✓ Fichiers HTML supprimés$(NC)"

PMOMusic/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "PMOMusic"
-version = "0.1.0"
+version = "0.3.48"
 edition = "2024"
 
 [dependencies]
 pmoconfig = { path = "../pmoconfig" }
 pmoupnp =  { path = "../pmoupnp"}
 pmomediarenderer = { path = "../pmomediarenderer" }
-pmomediaserver = { path = "../pmomediaserver", features = ["qobuz", "paradise", "paradise-api", "api"] }
+pmomediaserver = { path = "../pmomediaserver", features = ["qobuz", "paradise", "paradise-api", "radiofrance", "api"] }
 pmosource = { path = "../pmosource", features = ["server"] }
 pmoserver = { path = "../pmoserver" }
 pmocovers = { path = "../pmocovers", features = ["pmoserver"] }
@@ -15,6 +15,7 @@ pmoaudiocache = { path = "../pmoaudiocache", features = ["pmoserver"]}
 pmoaudio-ext = { path = "../pmoaudio-ext", features = ["all"] }
 pmoapp = { path = "../pmoapp", features = ["pmoserver"] }
 pmocontrol = { path = "../pmocontrol", features = ["pmoserver"] }
+pmowebrenderer = { path = "../pmowebrenderer", features = ["pmoserver"] }
 
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync", "time", "signal"] }
 tracing = { workspace = true }