diff --git a/.DS_Store b/.DS_Store
index b4d7ee26..8c67cf49 100644
Binary files a/.DS_Store and b/.DS_Store differ
diff --git a/Blackboard/ToThinkAbout/plant_webrenderer_server_side_streaming.md b/Blackboard/ToThinkAbout/plant_webrenderer_server_side_streaming.md
new file mode 100644
index 00000000..6f5709a9
--- /dev/null
+++ b/Blackboard/ToThinkAbout/plant_webrenderer_server_side_streaming.md
@@ -0,0 +1,1193 @@
+# Plan d'implémentation détaillé : WebRenderer streaming audio côté serveur
+
+## Synthèse de l'exploration du code
+
+### Architecture actuelle
+
+L'architecture actuelle repose sur :
+
+1. `pmowebrenderer/src/websocket.rs` - Handler WebSocket : crée ou reconnecte un device UPnP par navigateur, envoie des commandes JSON au navigateur
+2. `pmowebrenderer/src/handlers.rs` - Action handlers UPnP qui forwardent vers le WebSocket via `SharedSender`
+3. `pmowebrenderer/src/session.rs` - `SessionManager` : HashMap token → session, persistance UDN/sender entre reconnexions
+4. `pmowebrenderer/src/state.rs` - `RendererState` + `SharedSender` (remplaçable à chaque reconnexion WS)
+5. `pmowebrenderer/src/renderer.rs` - `WebRendererFactory` : construit les services UPnP (AVTransport, RenderingControl, ConnectionManager)
+6. `pmowebrenderer/src/config.rs` - Trait `WebRendererExt` : enregistre la route WS dans pmoserver
+7. Frontend : `useWebRenderer.ts` - composable Vue.js gérant WebSocket + `GaplessEngine` (deux `HTMLAudioElement` en ping-pong)
+
+### Infrastructure réutilisable confirmée
+
+- `StreamingFlacSink` + `StreamHandle` dans `pmoaudio-ext/src/sinks/streaming_flac_sink.rs` : broadcast multi-clients, gapless, backpressure, header FLAC caché pour late-joiners
+- Pattern HTTP streaming dans `pmomediaserver/src/paradise_streaming.rs` : `Body::from_stream(ReaderStream::new(stream))` avec headers corrects
+- `PlaylistSource` dans `pmoaudio-ext/src/sources/playlist_source.rs` : modèle pour `source_loader.rs`, incluant décodage FLAC via `pmoflac::decode_audio_stream`, gestion cache progressif
+- `pmoserver::Server` : API `add_handler_with_state`, `add_post_handler_with_state`, `add_any_handler_with_state`, `add_router`
+
+### Dépendances existantes de pmowebrenderer
+
+Le crate actuel ne dépend pas de `pmoaudio-ext`, `pmoaudio`, `pmoflac` ou `pmoaudiocache`. Il faudra les ajouter.
+
+---
+
+## Ordre d'implémentation
+
+Les étapes sont organisées de façon à avoir un système compilable et testable à chaque jalon, en allant des fondations vers l'intégration.
+
+---
+
+## Etape 1 : Préparer le `Cargo.toml` de pmowebrenderer
+
+**Fichier concerné :** `pmowebrenderer/Cargo.toml`
+
+**Modifications :**
+```toml
+[dependencies]
+# Existants conservés
+pmoupnp = { path = "../pmoupnp" }
+pmomediarenderer = { path = "../pmomediarenderer" }
+pmoserver = { path = "../pmoserver", optional = true }
+pmocontrol = { path = "../pmocontrol", optional = true }
+pmoconfig = { path = "../pmoconfig" }
+
+# Nouveaux : pipeline audio
+pmoaudio-ext = { path = "../pmoaudio-ext", features = ["http-stream", "playlist"], optional = true }
+pmoaudio = { path = "../pmoaudio", optional = true }
+pmoflac = { path = "../pmoflac", optional = true }
+pmoaudiocache = { path = "../pmoaudiocache", optional = true }
+pmometadata = { path = "../pmometadata", optional = true }
+
+# Async runtime
+tokio = { workspace = true, features = ["full"] }
+async-trait = { workspace = true }
+
+# HTTP streaming (on retire "ws" de axum si WebSocket supprimé en phase finale)
+axum = { workspace = true, features = ["ws"] }  # garder "ws" pendant la migration
+axum-extra = { version = "0.9", features = ["typed-header"] }
+tower-http = { version = "0.6", features = ["fs", "trace"] }
+futures = "0.3"
+bytes = "1.0"
+tokio-util = { version = "0.7", features = ["io"] }
+
+# Serialization
+serde = { workspace = true }
+serde_json = { workspace = true }
+
+# Utilities
+uuid = { workspace = true, features = ["v4", "serde"] }
+parking_lot = "0.12"
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+pmodidl = { path = "../pmodidl" }
+pmoutils = { path = "../pmoutils" }
+
+[features]
+default = []
+pmoserver = ["dep:pmoserver", "dep:pmocontrol"]
+audio-pipeline = ["dep:pmoaudio-ext", "dep:pmoaudio", "dep:pmoflac", "dep:pmoaudiocache", "dep:pmometadata"]
+```
+
+**Note :** Ajouter `pmoaudio-ext` dans le workspace `Cargo.toml` (il n'y est pas encore).
+
+**Piège :** `pmoaudio-ext` n'est pas dans `[workspace.members]` du `Cargo.toml` racine. Il faut l'y ajouter. Vérifier aussi que `pmoaudio-ext` avec feature `playlist` n'introduit pas de dépendance circulaire via `pmoplaylist`.
+
+---
+
+## Etape 2 : Créer `pipeline.rs` — canal de contrôle et état par instance
+
+**Fichier :** `pmowebrenderer/src/pipeline.rs` (nouveau)
+
+Ce module définit les types partagés entre tous les handlers sans logique de pipeline encore.
+
+```rust
+use tokio::sync::mpsc;
+
+/// Commandes envoyées au pipeline audio de l'instance
+#[derive(Debug)]
+pub enum PipelineControl {
+    LoadUri(String),
+    LoadNextUri(String),
+    Play,
+    Pause,
+    Stop,
+    Seek(f64),        // secondes
+    SetVolume(u16),   // 0-100
+    SetMute(bool),
+}
+
+/// Handle vers le pipeline audio d'une instance WebRenderer serveur
+#[derive(Clone)]
+pub struct PipelineHandle {
+    /// Canal de contrôle vers la task pipeline
+    pub control_tx: mpsc::Sender<PipelineControl>,
+    /// Token d'annulation pour stopper le pipeline
+    pub stop_token: tokio_util::sync::CancellationToken,
+}
+
+impl PipelineHandle {
+    pub async fn send(&self, cmd: PipelineControl) {
+        let _ = self.control_tx.send(cmd).await;
+    }
+}
+```
+
+**Points d'attention :**
+- `PipelineControl` doit être `Send` (pas de `Arc<RwLock<...>>` dans les variantes).
+- Le `CancellationToken` de `tokio_util` est déjà utilisé dans `pmoaudio-ext`, importer depuis là.
+
+---
+
+## Etape 3 : Modifier `state.rs` — ajouter stream handle et pipeline handle
+
+**Fichier :** `pmowebrenderer/src/state.rs` (modifier)
+
+Remplacer `SharedSender` (qui envoie vers le WS) par un `SharedStreamHandle` et un `PipelineHandle`.
+
+```rust
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+#[cfg(feature = "audio-pipeline")]
+use pmoaudio_ext::sinks::streaming_flac_sink::StreamHandle;
+
+use crate::messages::PlaybackState;
+#[cfg(feature = "audio-pipeline")]
+use crate::pipeline::PipelineHandle;
+
+/// État temps-réel du renderer (partagé backend ↔ pipeline)
+#[derive(Debug, Clone)]
+pub struct RendererState {
+    pub playback_state: PlaybackState,
+    pub current_uri: Option<String>,
+    pub current_metadata: Option<String>,
+    pub next_uri: Option<String>,
+    pub next_metadata: Option<String>,
+    pub position: Option<String>,   // mis à jour par la task de suivi position
+    pub duration: Option<String>,
+    pub volume: u16,
+    pub mute: bool,
+}
+
+impl Default for RendererState { /* identique à l'existant */ }
+
+pub type SharedState = Arc<RwLock<RendererState>>;
+
+/// Handle vers le flux FLAC HTTP d'une instance (remplace SharedSender)
+#[cfg(feature = "audio-pipeline")]
+#[derive(Clone)]
+pub struct SharedStreamHandle(Arc<RwLock<Option<StreamHandle>>>);
+
+#[cfg(feature = "audio-pipeline")]
+impl SharedStreamHandle {
+    pub fn new(handle: StreamHandle) -> Self {
+        Self(Arc::new(RwLock::new(Some(handle))))
+    }
+
+    pub fn get(&self) -> Option<StreamHandle> {
+        self.0.read().clone()
+    }
+
+    pub fn clear(&self) {
+        *self.0.write() = None;
+    }
+}
+
+// Pour la compatibilité avec les handlers qui utilisent encore SharedSender
+// pendant la phase de migration, on conserve SharedSender dans le module
+// mais on la rend conditionnelle au feature "pmoserver" seul (sans audio-pipeline).
+```
+
+**Points d'attention :**
+- Conserver `SharedSender` derrière une feature flag pendant la migration. Les handlers UPnP existants (`handlers.rs`) l'utilisent encore.
+- La `StreamHandle` de `pmoaudio-ext` est `Clone` — on peut la partager sans `Arc<RwLock<...>>` en réalité, mais un wrapper permet de la remplacer à la reconnexion.
+
+---
+
+## Etape 4 : Créer `source_loader.rs` — ouverture d'URI arbitraires
+
+**Fichier :** `pmowebrenderer/src/source_loader.rs` (nouveau)
+
+Ce module sait ouvrir une URI quelconque (URL HTTP, chemin fichier local, chemin Samba) et la transformer en `AsyncRead` de bytes PCM via `pmoflac::decode_audio_stream`.
+
+```rust
+use pmoflac::decode_audio_stream;
+use std::path::Path;
+use tokio::io::AsyncRead;
+
+pub enum SourceKind {
+    LocalFile(std::path::PathBuf),
+    HttpUrl(String),
+}
+
+pub fn classify_uri(uri: &str) -> SourceKind {
+    if uri.starts_with("http://") || uri.starts_with("https://") {
+        SourceKind::HttpUrl(uri.to_string())
+    } else {
+        // Chemin fichier (absolu ou Samba monté)
+        SourceKind::LocalFile(std::path::PathBuf::from(uri))
+    }
+}
+
+/// Ouvre une source audio quelconque et retourne le stream PCM décodé.
+/// Retourne (stream, sample_rate, bits_per_sample, channels)
+pub async fn open_uri(
+    uri: &str,
+) -> Result<(impl AsyncRead + Send + Unpin, pmoflac::StreamInfo), SourceError> {
+    match classify_uri(uri) {
+        SourceKind::LocalFile(path) => {
+            let file = tokio::fs::File::open(&path).await
+                .map_err(|e| SourceError::Io(e.to_string()))?;
+            let stream = decode_audio_stream(file).await
+                .map_err(|e| SourceError::Decode(e.to_string()))?;
+            let info = stream.info().clone();
+            Ok((stream, info))
+        }
+        SourceKind::HttpUrl(url) => {
+            // Utiliser reqwest pour streamer l'URL HTTP externe
+            // Même approche que pmoaudiocache qui télécharge depuis URLs Qobuz
+            let response = reqwest::get(&url).await
+                .map_err(|e| SourceError::Http(e.to_string()))?;
+            let byte_stream = response.bytes_stream();
+            // Convertir en AsyncRead
+            use tokio_util::io::StreamReader;
+            use futures::TryStreamExt;
+            let reader = StreamReader::new(
+                byte_stream.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
+            );
+            let stream = decode_audio_stream(reader).await
+                .map_err(|e| SourceError::Decode(e.to_string()))?;
+            let info = stream.info().clone();
+            Ok((stream, info))
+        }
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum SourceError {
+    #[error("IO error: {0}")]
+    Io(String),
+    #[error("Decode error: {0}")]
+    Decode(String),
+    #[error("HTTP error: {0}")]
+    Http(String),
+}
+```
+
+**Points d'attention :**
+- `decode_audio_stream` prend un `AsyncRead + Send + Unpin`. `tokio::fs::File` et `StreamReader` satisfont ces contraintes.
+- Pour les URLs Qobuz (URLs signées avec expiration), la source sera ouverte immédiatement par le handler `SetAVTransportURI` — pas de retry automatique. Si l'URL expire pendant la lecture, le pipeline s'arrêtera proprement via `StopReason`.
+- Les chemins Samba supposent que le partage est monté localement sur le serveur. Aucun traitement spécial nécessaire, `tokio::fs::File::open` suffit.
+- Ajouter `reqwest` en dépendance de pmowebrenderer avec feature `stream`.
+
+---
+
+## Etape 5 : Créer `pipeline.rs` — logique complète du pipeline audio
+
+**Fichier :** `pmowebrenderer/src/pipeline.rs` (compléter l'étape 2)
+
+La task pipeline tourne en background pour chaque instance. Elle reçoit des `PipelineControl`, ouvre les sources via `source_loader`, alimente la `StreamingFlacSink`.
+
+```rust
+use pmoaudio::{
+    AudioChunk, AudioChunkData, AudioError, AudioSegment, _AudioSegment,
+    pipeline::{AudioPipelineNode, PipelineHandle as AudioPipelineHandle},
+};
+use pmoaudio_ext::sinks::streaming_flac_sink::{StreamHandle, StreamingFlacSink};
+use pmoflac::EncoderOptions;
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+
+pub struct InstancePipeline {
+    pub stream_handle: StreamHandle,
+    pub control_tx: mpsc::Sender<PipelineControl>,
+    pub stop_token: CancellationToken,
+}
+
+impl InstancePipeline {
+    /// Crée et démarre un pipeline pour une instance WebRenderer.
+    /// Retourne immédiatement ; la task tourne en background.
+    pub fn start() -> Self {
+        let stop_token = CancellationToken::new();
+        let (control_tx, mut control_rx) = mpsc::channel::<PipelineControl>(16);
+        let (sink, stream_handle) = StreamingFlacSink::new(
+            EncoderOptions::default(),
+            24, // bits_per_sample — 24 bits pour haute qualité
+        );
+
+        // La task de pipeline gère le cycle de vie
+        let stop_token_clone = stop_token.clone();
+        let sink_arc: Arc<Mutex<Option<Box<dyn AudioPipelineNode>>>> =
+            Arc::new(Mutex::new(None));
+
+        tokio::spawn(pipeline_task(
+            control_rx,
+            stop_token_clone,
+            sink,
+        ));
+
+        Self {
+            stream_handle,
+            control_tx,
+            stop_token,
+        }
+    }
+}
+
+async fn pipeline_task(
+    mut control_rx: mpsc::Receiver<PipelineControl>,
+    stop_token: CancellationToken,
+    sink: StreamingFlacSink,
+) {
+    // État interne de la task
+    let mut current_pipeline_handle: Option<AudioPipelineHandle> = None;
+    let mut pending_next_uri: Option<String> = None;
+
+    // La StreamingFlacSink est démarrée une fois, tourne en continu.
+    // Le canal PCM (sink.get_tx()) reçoit les AudioSegments.
+    // Pour l'alimenter, on lance une task source séparée par piste.
+
+    let sink_tx = sink.get_tx().expect("StreamingFlacSink must have a tx");
+    let sink_stop = stop_token.clone();
+    tokio::spawn(async move {
+        Box::new(sink).run(sink_stop).await.ok();
+    });
+
+    loop {
+        tokio::select! {
+            _ = stop_token.cancelled() => {
+                // Stopper la source courante
+                if let Some(h) = current_pipeline_handle.take() {
+                    h.stop();
+                }
+                break;
+            }
+
+            cmd = control_rx.recv() => {
+                match cmd {
+                    None => break,
+                    Some(PipelineControl::LoadUri(uri)) => {
+                        // Stopper la source courante si elle existe
+                        if let Some(h) = current_pipeline_handle.take() {
+                            h.stop();
+                        }
+                        // Lancer une nouvelle source
+                        current_pipeline_handle = Some(
+                            spawn_source_task(uri, sink_tx.clone(), stop_token.clone()).await
+                        );
+                    }
+                    Some(PipelineControl::LoadNextUri(uri)) => {
+                        pending_next_uri = Some(uri);
+                    }
+                    Some(PipelineControl::Play) => {
+                        // Pipeline serveur : Play ne fait rien de spécial
+                        // La source alimente automatiquement dès LoadUri
+                    }
+                    Some(PipelineControl::Stop) => {
+                        if let Some(h) = current_pipeline_handle.take() {
+                            h.stop();
+                        }
+                        // Envoyer EndOfStream au sink
+                        let _ = sink_tx.send(Arc::new(AudioSegment::new_end_of_stream(0, 0.0))).await;
+                    }
+                    Some(PipelineControl::Seek(pos_sec)) => {
+                        // Pour seek : stopper la source, relancer depuis la position
+                        if let Some(current_uri) = get_current_uri() {
+                            if let Some(h) = current_pipeline_handle.take() {
+                                h.stop();
+                            }
+                            current_pipeline_handle = Some(
+                                spawn_source_task_from(current_uri, pos_sec, sink_tx.clone(), stop_token.clone()).await
+                            );
+                        }
+                    }
+                    Some(PipelineControl::SetVolume(vol)) => {
+                        // TODO : Volume DSP côté serveur (hors scope initial)
+                    }
+                    Some(PipelineControl::SetMute(mute)) => {
+                        // TODO
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+```
+
+**Points d'attention critiques :**
+
+1. **Gapless** : Le gapless avec `StreamingFlacSink` en mode `restart_encoder_on_track_boundary: false` signifie que le flux FLAC est continu. La frontière de piste est gérée par `SyncMarker::TrackBoundary`. Pour enchaîner deux sources indépendantes, il faut envoyer un `SyncMarker::TrackBoundary` entre les deux flux PCM vers le sink. La `StreamingFlacSink` ne restarte pas l'encodeur — le navigateur ne voit pas d'interruption.
+
+2. **Architecture source** : La source doit envoyer des `Arc<AudioSegment>` directement au `sink_tx` (le canal d'entrée de `StreamingFlacSink`). Ce n'est pas la même architecture que `Node<PlaylistSourceLogic>` qui utilise les `children`. Ici, on alimente directement le sink via son `Sender<Arc<AudioSegment>>`. C'est exact car `sink.get_tx()` retourne le `Sender` d'entrée du `Node<StreamingFlacSinkLogic>`.
+
+3. **Position tracking** : Sans retour du navigateur (le navigateur ne connaît que le flux FLAC), la position doit être trackée côté serveur. La `StreamingFlacSink` maintient un `current_timestamp` accessible via `StreamHandle` (indirectement via les métadonnées). Une task périodique lit ce timestamp et met à jour `RendererState.position`.
+
+4. **Seek** : Un seek implique de relancer la source depuis une position donnée. Pour les fichiers FLAC locaux, `pmoflac::decode_audio_stream` ne supporte pas le seek natif sur un stream. Il faudra rouvrir le fichier et lire en avançant les frames. Approche pragmatique : seek = stop + reopen + skip samples (coûteux mais simple). Le navigateur rebuffère ~1s comme indiqué dans l'archi.
+
+---
+
+## Etape 6 : Créer `register.rs` — handlers POST /register et DELETE /{id}
+
+**Fichier :** `pmowebrenderer/src/register.rs` (nouveau)
+
+Ce module remplace `websocket.rs`. La logique de création du device UPnP est ici, adaptée du code de `create_renderer_for_browser` dans `websocket.rs`.
+
+```rust
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+    Json,
+};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+use crate::registry::RendererRegistry;
+use crate::pipeline::InstancePipeline;
+
+#[derive(Debug, Deserialize)]
+pub struct RegisterRequest {
+    pub instance_id: String,
+    pub user_agent: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct RegisterResponse {
+    pub stream_url: String,
+}
+
+/// POST /api/webrenderer/register
+pub async fn register_handler(
+    State(registry): State<Arc<RendererRegistry>>,
+    Json(req): Json<RegisterRequest>,
+) -> impl IntoResponse {
+    match registry.register_or_reconnect(&req.instance_id, &req.user_agent).await {
+        Ok(stream_url) => (StatusCode::OK, Json(RegisterResponse { stream_url })).into_response(),
+        Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response(),
+    }
+}
+
+/// DELETE /api/webrenderer/{id}
+pub async fn unregister_handler(
+    State(registry): State<Arc<RendererRegistry>>,
+    Path(instance_id): Path<String>,
+) -> impl IntoResponse {
+    registry.unregister(&instance_id).await;
+    StatusCode::NO_CONTENT
+}
+```
+
+**Points d'attention :**
+- La logique de `create_renderer_for_browser` dans `websocket.rs` gère 4 cas (reconnexion session active, device dans registry mais session expirée, première connexion, etc.). Cette logique doit être reprise quasi à l'identique dans `RendererRegistry::register_or_reconnect`.
+- La `stream_url` retournée est `/api/webrenderer/{instance_id}/stream` — URL relative, correcte en local et via proxy.
+- Plus de `SharedSender` dans `WebRendererSession`. À la place : `stream_handle: SharedStreamHandle` + `pipeline: PipelineHandle`.
+
+---
+
+## Etape 7 : Créer `stream.rs` — handler HTTP GET /stream
+
+**Fichier :** `pmowebrenderer/src/stream.rs` (nouveau)
+
+Ce module suit exactement le pattern de `pmomediaserver/src/paradise_streaming.rs`.
+
+```rust
+use axum::{
+    body::Body,
+    extract::{Path, State},
+    http::{
+        StatusCode,
+        header::{ACCEPT_RANGES, CACHE_CONTROL, CONNECTION, CONTENT_TYPE},
+    },
+    response::{IntoResponse, Response},
+};
+use std::sync::Arc;
+use tokio_util::io::ReaderStream;
+
+use crate::registry::RendererRegistry;
+
+/// GET /api/webrenderer/{id}/stream
+///
+/// Retourne le flux FLAC continu de l'instance.
+/// La déconnexion du client est détectée automatiquement par la coupure du flux.
+pub async fn stream_handler(
+    State(registry): State<Arc<RendererRegistry>>,
+    Path(instance_id): Path<String>,
+) -> impl IntoResponse {
+    let handle = match registry.get_stream_handle(&instance_id).await {
+        Some(h) => h,
+        None => return StatusCode::NOT_FOUND.into_response(),
+    };
+
+    // Abonner ce client au flux FLAC
+    let flac_stream = handle.subscribe_flac();
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, "audio/flac")
+        .header(CACHE_CONTROL, "no-store, no-transform")
+        .header(CONNECTION, "keep-alive")
+        .header(ACCEPT_RANGES, "none")
+        .body(Body::from_stream(ReaderStream::new(flac_stream)))
+        .unwrap()
+        .into_response()
+}
+```
+
+**Points d'attention :**
+- `ReaderStream` de `tokio-util` convertit un `AsyncRead` en `Stream<Item=Result<Bytes>>`. `FlacClientStream` implémente `AsyncRead`. Le pattern est identique à `paradise_streaming.rs`.
+- La détection de déconnexion se fait via `FlacClientStream::Drop` qui décrémente le compteur de clients dans `StreamHandle::client_disconnected()`. La `StreamingFlacSink` peut être configurée avec `set_auto_stop(true)` pour stopper le pipeline si plus aucun client n'écoute.
+- Un client qui se reconnecte (`reload` de page) reçoit d'abord le header FLAC caché dans `SharedStreamHandleInner::header`, puis la suite du flux courant via `register_client()`. Ce mécanisme est déjà dans `SharedStreamHandleInner` — vérifier que `subscribe_flac()` envoie bien le header en premier (c'est le cas dans l'implémentation actuelle via `header_cache`).
+
+---
+
+## Etape 8 : Créer `registry.rs` — remplace `session.rs`
+
+**Fichier :** `pmowebrenderer/src/registry.rs` (nouveau)
+
+Le `RendererRegistry` remplace `SessionManager`. La session est maintenant liée au flux FLAC, pas au WebSocket.
+
+```rust
+use parking_lot::RwLock;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+
+use pmoupnp::devices::DeviceInstance;
+
+#[cfg(feature = "audio-pipeline")]
+use crate::pipeline::{InstancePipeline, PipelineHandle};
+#[cfg(feature = "audio-pipeline")]
+use crate::state::SharedStreamHandle;
+use crate::state::SharedState;
+
+/// Instance WebRenderer côté serveur
+pub struct WebRendererInstance {
+    pub instance_id: String,       // UUID stable du navigateur (localStorage)
+    pub udn: String,               // "uuid:{instance_id}"
+    pub device_instance: Arc<DeviceInstance>,
+    pub state: SharedState,
+    #[cfg(feature = "audio-pipeline")]
+    pub stream_handle: SharedStreamHandle,
+    #[cfg(feature = "audio-pipeline")]
+    pub pipeline: PipelineHandle,
+    pub created_at: SystemTime,
+    pub last_stream_connect: Arc<RwLock<Option<SystemTime>>>,
+}
+
+/// Registre global des instances WebRenderer actives
+pub struct RendererRegistry {
+    instances: Arc<RwLock<HashMap<String, Arc<WebRendererInstance>>>>,
+    /// Map UDN → instance, pour retrouver par UDN depuis les handlers UPnP
+    by_udn: Arc<RwLock<HashMap<String, Arc<WebRendererInstance>>>>,
+    #[cfg(feature = "pmoserver")]
+    control_point: Arc<pmocontrol::ControlPoint>,
+}
+
+impl RendererRegistry {
+    /// Enregistre ou reconnecte une instance.
+    /// Retourne l'URL de stream relative.
+    pub async fn register_or_reconnect(
+        &self,
+        instance_id: &str,
+        user_agent: &str,
+    ) -> Result<String, crate::error::WebRendererError> {
+        // Vérifier si une instance existe déjà pour cet instance_id
+        {
+            let instances = self.instances.read();
+            if let Some(existing) = instances.get(instance_id) {
+                // Reconnexion : l'instance existe, le pipeline tourne toujours
+                // Réannoncer auprès du ControlPoint
+                #[cfg(feature = "pmoserver")]
+                self.register_with_control_point(&existing.device_instance)?;
+
+                tracing::info!(instance_id, "WebRenderer: reconnected");
+                return Ok(format!("/api/webrenderer/{}/stream", instance_id));
+            }
+        }
+
+        // Première connexion : créer device UPnP + pipeline
+        // (Reprend la logique de create_renderer_for_browser dans websocket.rs)
+        let instance = self.create_instance(instance_id, user_agent).await?;
+        let stream_url = format!("/api/webrenderer/{}/stream", instance_id);
+
+        let instance = Arc::new(instance);
+        {
+            let mut instances = self.instances.write();
+            instances.insert(instance_id.to_string(), instance.clone());
+        }
+        {
+            let mut by_udn = self.by_udn.write();
+            by_udn.insert(instance.udn.clone(), instance.clone());
+        }
+
+        tracing::info!(instance_id, "WebRenderer: registered new instance");
+        Ok(stream_url)
+    }
+
+    /// Retourne le StreamHandle pour l'endpoint /stream
+    pub async fn get_stream_handle(&self, instance_id: &str) -> Option<StreamHandle> {
+        self.instances.read()
+            .get(instance_id)
+            .and_then(|i| i.stream_handle.get())
+    }
+
+    /// Retourne le PipelineHandle pour les handlers UPnP
+    pub fn get_pipeline_by_udn(&self, udn: &str) -> Option<PipelineHandle> {
+        self.by_udn.read()
+            .get(udn)
+            .map(|i| i.pipeline.clone())
+    }
+
+    pub fn get_state_by_udn(&self, udn: &str) -> Option<SharedState> {
+        self.by_udn.read()
+            .get(udn)
+            .map(|i| i.state.clone())
+    }
+
+    pub async fn unregister(&self, instance_id: &str) {
+        if let Some(instance) = self.instances.write().remove(instance_id) {
+            self.by_udn.write().remove(&instance.udn);
+            // Stopper le pipeline
+            instance.pipeline.stop_token.cancel();
+            // Annoncer SSDP byebye
+            #[cfg(feature = "pmoserver")]
+            if let Ok(mut registry) = self.control_point.registry().write() {
+                registry.device_says_byebye(&instance.udn);
+            }
+            tracing::info!(instance_id, "WebRenderer: unregistered");
+        }
+    }
+}
+```
+
+**Points d'attention :**
+- La méthode `create_instance` reprend quasi mot pour mot la logique de `create_renderer_for_browser` dans `websocket.rs` (vérifier registry DEVICE_REGISTRY, créer device model, `server.register_device`, `register_with_control_point`), mais au lieu de créer `SharedSender`, elle crée `InstancePipeline::start()`.
+- Le cleanup "session expirée" de l'ancien `SessionManager` est remplacé par la détection de déconnexion du flux FLAC : quand `FlacClientStream` est droppé, `client_disconnected()` est appelé. Si `auto_stop` est activé, le pipeline s'arrête.
+- Cleanup proactif via une task de polling : si le dernier client FLAC s'est déconnecté depuis plus de 5 minutes et que le ControlPoint indique que le renderer n'est plus en usage, on peut unregister.
+
+---
+
+## Etape 9 : Modifier `handlers.rs` — brancher sur le pipeline au lieu du WS
+
+**Fichier :** `pmowebrenderer/src/handlers.rs` (modifier)
+
+Les handlers UPnP ne font plus `ws.send(...)` mais `pipeline.send(PipelineControl::...)`.
+
+```rust
+// Nouveau play_handler
+pub fn play_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
+    Arc::new(move |data: ActionData| -> ActionFuture {
+        let pipeline = pipeline.clone();
+        let state = state.clone();
+        Box::pin(async move {
+            pipeline.send(PipelineControl::Play).await;
+            state.write().playback_state = PlaybackState::Playing;
+            Ok(data)
+        })
+    })
+}
+
+// Nouveau set_uri_handler — la différence clé
+pub fn set_uri_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
+    Arc::new(move |data: ActionData| -> ActionFuture {
+        let pipeline = pipeline.clone();
+        let state = state.clone();
+        Box::pin(async move {
+            let uri: String = get!(&data, "CurrentURI", String);
+            let metadata: String = /* ... identique à l'existant ... */;
+
+            // Envoyer au pipeline serveur (plus de WebSocket)
+            pipeline.send(PipelineControl::LoadUri(uri.clone())).await;
+
+            {
+                let mut s = state.write();
+                s.current_uri = Some(uri);
+                s.current_metadata = Some(metadata);
+                s.playback_state = PlaybackState::Transitioning;
+            }
+            Ok(data)
+        })
+    })
+}
+
+// set_next_uri_handler
+pub fn set_next_uri_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
+    Arc::new(move |data: ActionData| -> ActionFuture {
+        let pipeline = pipeline.clone();
+        let state = state.clone();
+        Box::pin(async move {
+            let uri: String = get!(&data, "NextURI", String);
+            let metadata: String = /* ... */;
+            pipeline.send(PipelineControl::LoadNextUri(uri.clone())).await;
+            {
+                let mut s = state.write();
+                s.next_uri = Some(uri);
+                s.next_metadata = Some(metadata);
+            }
+            Ok(data)
+        })
+    })
+}
+
+// seek_handler
+pub fn seek_handler(pipeline: PipelineHandle) -> ActionHandler {
+    Arc::new(move |data: ActionData| -> ActionFuture {
+        let pipeline = pipeline.clone();
+        Box::pin(async move {
+            let target: String = get!(&data, "Target", String);
+            // Convertir "H:MM:SS" en secondes
+            let pos_sec = upnp_time_to_seconds(&target);
+            pipeline.send(PipelineControl::Seek(pos_sec)).await;
+            Ok(data)
+        })
+    })
+}
+
+// Volume et Mute : côté serveur ou navigateur ?
+// Phase initiale : volume = 100 fixe côté serveur, navigateur gère avec l'élément <audio>
+// Donc set_volume_handler et set_mute_handler mettent à jour l'état mais n'envoient
+// pas encore au pipeline (pas de DSP volume implémenté).
+pub fn set_volume_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
+    Arc::new(move |data: ActionData| -> ActionFuture {
+        let pipeline = pipeline.clone();
+        let state = state.clone();
+        Box::pin(async move {
+            let volume: u16 = get!(&data, "DesiredVolume", u16);
+            pipeline.send(PipelineControl::SetVolume(volume)).await;
+            state.write().volume = volume;
+            Ok(data)
+        })
+    })
+}
+```
+
+**Points d'attention :**
+- Supprimer toutes les références à `SharedSender` et `ServerMessage` dans `handlers.rs`.
+- La conversion "H:MM:SS" → secondes était côté navigateur (dans `GaplessEngine::seek`). Il faut la déplacer côté serveur dans `handlers.rs`.
+- `get_position_info_handler` et `get_transport_info_handler` restent inchangés (lisent `SharedState`).
+
+---
+
+## Etape 10 : Modifier `renderer.rs` — `WebRendererFactory` avec pipeline
+
+**Fichier :** `pmowebrenderer/src/renderer.rs` (modifier)
+
+Remplacer la signature de `create_device_with_name` : au lieu de prendre un `ws_sender`, prendre un `PipelineHandle`.
+
+```rust
+impl WebRendererFactory {
+    pub fn create_device_with_pipeline(
+        device_name: &str,
+        browser_ua: &str,
+        pipeline: PipelineHandle,
+        state: SharedState,
+    ) -> Result<Device, FactoryError> {
+        let avtransport = Self::build_avtransport(pipeline.clone(), state.clone())?;
+        let renderingcontrol = Self::build_renderingcontrol(pipeline.clone(), state.clone())?;
+        let connectionmanager = Self::build_connectionmanager()?;
+
+        let short_name = extract_browser_name(browser_ua);
+        let device = Device::new(
+            device_name.to_string(),
+            "MediaRenderer".to_string(),
+            format!("Web Audio – {}", short_name),
+        );
+        // ...
+        Ok(device)
+    }
+}
+```
+
+**Points d'attention :**
+- `build_avtransport` et `build_renderingcontrol` prennent maintenant `PipelineHandle` au lieu de `SharedSender`.
+- Le `ConnectionManager` déclarait des formats supportés dans `get_protocol_info_handler`. Mettre à jour pour n'annoncer que `audio/flac` puisque le navigateur ne gère plus que du FLAC serveur-side.
+
+---
+
+## Etape 11 : Modifier `config.rs` — nouvelles routes, supprimer WS
+
+**Fichier :** `pmowebrenderer/src/config.rs` (modifier)
+
+Remplacer l'enregistrement de la route WebSocket par les trois nouvelles routes.
+
+```rust
+#[async_trait]
+impl WebRendererExt for pmoserver::Server {
+    async fn register_web_renderer(
+        &mut self,
+        control_point: Arc<ControlPoint>,
+    ) -> Result<(), WebRendererError> {
+        let registry = Arc::new(RendererRegistry::new(control_point));
+
+        // POST /api/webrenderer/register
+        self.add_post_handler_with_state(
+            "/api/webrenderer/register",
+            register_handler,
+            registry.clone(),
+        ).await;
+
+        // GET /api/webrenderer/{id}/stream  (sous-router pour param dynamique)
+        let stream_router = Router::new()
+            .route("/{id}/stream", get(stream_handler))
+            .with_state(registry.clone());
+        self.add_router("/api/webrenderer", stream_router).await;
+
+        // DELETE /api/webrenderer/{id}
+        let delete_router = Router::new()
+            .route("/{id}", axum::routing::delete(unregister_handler))
+            .with_state(registry.clone());
+        self.add_router("/api/webrenderer", delete_router).await;
+
+        tracing::info!("WebRenderer server-side streaming endpoints registered");
+        Ok(())
+    }
+}
+```
+
+**Points d'attention :**
+- `add_post_handler_with_state` existe dans `pmoserver::Server` (vu dans `server.rs`).
+- Pour les routes avec paramètres dynamiques (`/{id}/stream`), utiliser `add_router` avec un sous-router Axum, car `add_handler_with_state` utilise `Router::route("/", ...)` qui ne supporte pas les paramètres.
+- Supprimer l'import de `websocket_handler` et `WebSocketState`.
+
+---
+
+## Etape 12 : Modifier `lib.rs` — mettre à jour les exports
+
+**Fichier :** `pmowebrenderer/src/lib.rs` (modifier)
+
+```rust
+mod error;
+mod handlers;
+mod pipeline;
+mod registry;
+mod renderer;
+mod source_loader;
+mod state;
+mod stream;
+mod register;
+
+#[cfg(feature = "pmoserver")]
+mod config;
+
+// Supprimer :
+// mod messages;  (ou garder pour PlaybackState seulement)
+// mod session;
+// mod websocket;
+
+pub use error::WebRendererError;
+pub use pipeline::PipelineControl;
+pub use renderer::WebRendererFactory;
+pub use registry::{RendererRegistry, WebRendererInstance};
+pub use state::{RendererState, SharedState};
+
+// Garder PlaybackState depuis messages.rs si d'autres crates en dépendent
+// Sinon le déplacer dans state.rs
+pub use messages::PlaybackState;
+
+#[cfg(feature = "pmoserver")]
+pub use config::WebRendererExt;
+```
+
+**Points d'attention :**
+- Vérifier si `PlaybackState` est importé par d'autres crates depuis `pmowebrenderer`. Si oui, le conserver dans `messages.rs` ou le déplacer dans `state.rs` en mettant à jour les imports.
+- `BrowserCapabilities`, `RendererInfo` ne sont plus nécessaires côté serveur mais peuvent être gardées si le frontend les utilise encore via une API dédiée.
+
+---
+
+## Etape 13 : Modifier le frontend — `useWebRenderer.ts`
+
+**Fichier :** `pmoapp/webapp/src/composables/useWebRenderer.ts` (modifier)
+
+Remplacer la connexion WebSocket et le `GaplessEngine` ping-pong par :
+1. Un `POST /api/webrenderer/register` au montage
+2. Un élément `<audio>` unique dont la `src` est la `stream_url`
+3. Plus de gestion de commandes (tout est côté serveur)
+
+```typescript
+export function useWebRenderer() {
+    const connected = ref(false);
+    const rendererInfo = ref<RendererInfo | null>(null);
+    const streamUrl = ref<string | null>(null);
+
+    const INSTANCE_ID_KEY = "pmomusic_webrenderer_instance_id";
+
+    function getOrCreateInstanceId(): string {
+        // ... identique à l'existant ...
+    }
+
+    async function register() {
+        const instanceId = getOrCreateInstanceId();
+
+        try {
+            const response = await fetch("/api/webrenderer/register", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    instance_id: instanceId,
+                    user_agent: navigator.userAgent,
+                }),
+            });
+
+            if (!response.ok) throw new Error(`HTTP ${response.status}`);
+
+            const data = await response.json() as { stream_url: string };
+            streamUrl.value = data.stream_url;
+            connected.value = true;
+
+            // Ici on attend que le SSE global notifie l'apparition du renderer
+            // (le ControlPoint émettra un event SSE "renderer_added")
+            rendererInfo.value = {
+                udn: `uuid:${instanceId.toLowerCase()}`,
+                // friendly_name récupéré depuis le SSE ou une API
+            };
+            onConnectedCallback?.();
+
+        } catch (e) {
+            console.error("[WebRenderer] Failed to register:", e);
+        }
+    }
+
+    async function unregister() {
+        const instanceId = getOrCreateInstanceId();
+        try {
+            await fetch(`/api/webrenderer/${instanceId}`, { method: "DELETE" });
+        } catch { /* ignore */ }
+        connected.value = false;
+        streamUrl.value = null;
+    }
+
+    onMounted(async () => {
+        await register();
+        window.addEventListener("beforeunload", () => void unregister());
+    });
+
+    onUnmounted(() => void unregister());
+
+    return {
+        connected: readonly(connected),
+        rendererInfo: readonly(rendererInfo),
+        streamUrl: readonly(streamUrl),  // exposé pour le template <audio :src="streamUrl">
+        onConnected(fn: () => void) { onConnectedCallback = fn; },
+    };
+}
+```
+
+**Points d'attention :**
+- L'élément `<audio :src="streamUrl">` doit être dans le template du composant qui utilise `useWebRenderer` (probablement `UnifiedControlView.vue`). La `src` pointe vers `/api/webrenderer/{instance_id}/stream`.
+- Le navigateur doit démarrer la lecture automatiquement quand il reçoit le flux FLAC. Cependant, l'autoplay est bloqué sans interaction utilisateur. Solution : afficher un bouton "Activer l'audio" qui déclenche `audioElement.play()` au premier clic.
+- La position, durée, titre/artiste ne viennent plus du navigateur. Ils viennent du SSE existant du ControlPoint. Vérifier que les événements SSE `state_changed`, `position_changed`, `metadata_changed` sont bien émis par le serveur lors des transitions de piste.
+- Supprimer `GaplessEngine`, la classe TypeScript entière et ses états internes.
+- La détection de fermeture de page (`beforeunload`) déclenche un `DELETE` qui est synchrone ou en best-effort. Utiliser `navigator.sendBeacon` pour garantir l'envoi.
+
+---
+
+## Etape 14 : Modifier `UnifiedControlView.vue` — intégrer le flux audio
+
+**Fichier :** `pmoapp/webapp/src/views/UnifiedControlView.vue` (modifier)
+
+Ajouter l'élément `<audio>` au template et connecter `streamUrl`.
+
+```vue
+<template>
+  <!-- ... template existant ... -->
+
+  <!-- Élément audio caché pour le flux WebRenderer serveur -->
+  <audio
+    v-if="webRenderer.streamUrl.value"
+    ref="audioElement"
+    :src="webRenderer.streamUrl.value"
+    preload="none"
+    style="display: none"
+  />
+
+  <!-- Bouton d'activation si autoplay bloqué -->
+  <button
+    v-if="webRenderer.connected.value && !audioStarted"
+    @click="startAudio"
+  >
+    Activer l'audio
+  </button>
+</template>
+
+<script setup lang="ts">
+// ...
+const audioElement = ref<HTMLAudioElement | null>(null);
+const audioStarted = ref(false);
+
+async function startAudio() {
+    if (audioElement.value) {
+        try {
+            await audioElement.value.play();
+            audioStarted.value = true;
+        } catch (e) {
+            console.warn("Cannot play audio:", e);
+        }
+    }
+}
+</script>
+```
+
+**Points d'attention :**
+- L'attribut `preload="none"` évite de démarrer le buffering avant que l'utilisateur ait interagi. Changer en `preload="auto"` après interaction initiale.
+- Une seule connexion au flux (un seul `<audio>`) par onglet suffit. Pas de ping-pong nécessaire.
+
+---
+
+## Etape 15 : Tâche de suivi de position côté serveur
+
+**Fichier :** `pmowebrenderer/src/registry.rs` ou `pipeline.rs` (modifier)
+
+Ajouter une task background qui lit la position depuis la `StreamingFlacSink` et met à jour `RendererState.position` et les variables UPnP.
+
+```rust
+/// Spawn une task qui met à jour la position dans l'état partagé toutes les secondes.
+fn spawn_position_tracker(
+    stream_handle: StreamHandle,
+    device_instance: Arc<DeviceInstance>,
+    state: SharedState,
+    stop_token: CancellationToken,
+) {
+    tokio::spawn(async move {
+        let mut interval = tokio::time::interval(std::time::Duration::from_secs(1));
+        loop {
+            tokio::select! {
+                _ = stop_token.cancelled() => break,
+                _ = interval.tick() => {
+                    // La StreamHandle expose get_metadata() qui contient audio_timestamp_sec
+                    let meta = stream_handle.get_metadata().await;
+                    let pos_sec = meta.audio_timestamp_sec;
+                    let pos_str = seconds_to_upnp_time(pos_sec);
+
+                    {
+                        let mut s = state.write();
+                        s.position = Some(pos_str.clone());
+                        // duration reste celle du dernier TrackBoundary metadata
+                    }
+
+                    // Mettre à jour les variables UPnP pour que GetPositionInfo retourne les bonnes valeurs
+                    update_position_vars(&device_instance, &pos_str, "").await;
+                }
+            }
+        }
+    });
+}
+```
+
+**Points d'attention :**
+- `MetadataSnapshot::audio_timestamp_sec` est mis à jour par la `StreamingFlacSink` via `update_metadata`. Vérifier que ce champ correspond bien à la position de lecture (timestamp courant du broadcaster).
+- La durée d'une piste n'est connue qu'à partir des métadonnées FLAC (STREAMINFO). Après `open_uri`, `stream.info().total_samples` divisé par `sample_rate` donne la durée. Stocker cette info dans `RendererState.duration` lors du `LoadUri`.
+
+---
+
+## Etape 16 : Gestion du TrackEnded côté serveur
+
+Dans l'ancienne architecture, le navigateur envoyait `TrackEnded` quand une piste se terminait, ce qui déclenchait `advance_queue_and_prefetch`. Maintenant, c'est le pipeline qui détecte la fin d'une source.
+
+**Dans `pipeline_task`**, quand la source courante se termine naturellement (EOF sans interruption) :
+
+```rust
+// Quand la source termine (EOF détecté dans spawn_source_task)
+let (next_uri, next_metadata) = {
+    let mut s = state.write();
+    let uri = s.next_uri.take();
+    let meta = s.next_metadata.take();
+    s.current_uri = uri.clone();
+    s.current_metadata = meta.clone();
+    s.next_uri = None;
+    s.next_metadata = None;
+    if uri.is_some() {
+        s.playback_state = PlaybackState::Playing;
+    } else {
+        s.playback_state = PlaybackState::Stopped;
+    }
+    (uri, meta)
+};
+
+// Mettre à jour les variables UPnP
+update_uri_vars(&device_instance, ...).await;
+update_transport_state_var(&device_instance, &new_state).await;
+
+// Notifier le ControlPoint (advance_queue_and_prefetch)
+if let Some(cp) = control_point.as_ref() {
+    let udn = device_instance.udn().to_string();
+    let cp = cp.clone();
+    tokio::spawn(async move {
+        cp.advance_queue_and_prefetch(&DeviceId(udn));
+    });
+}
+
+// Si next_uri existe, lancer automatiquement la piste suivante
+if let Some(uri) = next_uri {
+    spawn_source_task(uri, sink_tx.clone(), stop_token.clone()).await;
+}
+```
+
+**Points d'attention :**
+- La logique de `TrackEnded` dans `websocket.rs` (lignes 195-256) doit être reprise presque à l'identique dans la task pipeline.
+- Le `pipeline_task` a besoin d'accéder à `device_instance` et `control_point` — les passer en paramètre à la création ou via un `Arc<WebRendererInstance>`.
+
+---
+
+## Etape 17 : Cleanup — supprimer websocket.rs et messages.rs
+
+**Fichiers à supprimer :** `pmowebrenderer/src/websocket.rs`, `pmowebrenderer/src/messages.rs`
+
+**Attention :** `messages.rs` contient `PlaybackState` qui est utilisé dans `state.rs`, `handlers.rs`, etc. Avant de supprimer, déplacer `PlaybackState` dans `state.rs` ou créer un `types.rs`.
+
+La suppression se fait en dernier, après que tout le reste compile.
+
+---
+
+## Récapitulatif de l'ordre d'implémentation
+
+| Etape | Fichier | Action |
+|-------|---------|--------|
+| 1 | `pmowebrenderer/Cargo.toml` | Ajouter dépendances audio |
+| 1 | Workspace `Cargo.toml` | Ajouter `pmoaudio-ext` aux membres |
+| 2-3 | `pipeline.rs` (squelette) + `state.rs` | Types PipelineControl, SharedStreamHandle |
+| 4 | `source_loader.rs` | Ouverture URI arbitraires |
+| 5 | `pipeline.rs` (complet) | Task pipeline avec spawn_source_task |
+| 6 | `register.rs` | Handlers POST/DELETE |
+| 7 | `stream.rs` | Handler GET /stream |
+| 8 | `registry.rs` | Remplace session.rs |
+| 9 | `handlers.rs` | Brancher sur PipelineHandle |
+| 10 | `renderer.rs` | Factory avec PipelineHandle |
+| 11 | `config.rs` | Nouvelles routes, supprimer WS |
+| 12 | `lib.rs` | Mettre à jour exports |
+| 13 | `useWebRenderer.ts` | POST register + audio element |
+| 14 | `UnifiedControlView.vue` | Intégrer audio element |
+| 15 | `registry.rs` ou `pipeline.rs` | Position tracker task |
+| 16 | `pipeline.rs` | TrackEnded côté serveur |
+| 17 | `websocket.rs`, `messages.rs` | Supprimer |
+
+---
+
+## Points d'attention généraux (pièges à éviter)
+
+### Pièges Rust
+
+1. **Dépendances cycliques** : `pmoaudio-ext` avec feature `playlist` dépend de `pmoplaylist` → `pmoaudiocache`. S'assurer que `pmowebrenderer` ne crée pas de cycle. La feature `http-stream` seule suffit pour `StreamingFlacSink` sans dépendre de `pmoplaylist`.
+
+2. **Lifetime du `StreamingFlacSink`** : La `StreamingFlacSink` doit vivre tant que des clients sont connectés. Elle ne peut pas être droppée tant que le `StreamHandle` existe. Stocker le `PipelineHandle` (contenant le `CancellationToken` et le `JoinHandle`) dans `WebRendererInstance` pour maintenir le pipeline en vie.
+
+3. **`spawn_source_task` et formats audio hétérogènes** : `PlaylistSource` produit du PCM hétérogène. `StreamingFlacSink` attend un type cohérent. Si la source est un FLAC 24bits/44100Hz, le sink l'encodera en FLAC 24bits. Si une piste suivante est 16bits/48000Hz, il faudrait un `ResamplingNode`. Pour la phase initiale, documenter cette limitation et accepter que des pistes de formats différents peuvent causer des artefacts dans le flux continu. La `StreamingFlacSink` détecte le sample_rate au premier chunk — un changement de sample_rate en cours de flux n'est pas géré proprement.
+
+4. **Seek pour les fichiers locaux** : `pmoflac::decode_audio_stream` retourne un stream séquentiel. Pour seek, ouvrir le fichier, décoder et dropper les frames jusqu'à la position cible. C'est O(n) mais acceptable pour les fichiers locaux. Pour les URLs HTTP (Qobuz), le seek implique une nouvelle requête HTTP avec `Range: bytes=N-` si le serveur le supporte, ou sinon un re-téléchargement depuis le début.
+
+5. **`add_post_handler_with_state` vs `add_handler_with_state`** : Vérifier la signature exacte dans `pmoserver`. `add_post_handler_with_state` utilise `routing::post(handler)` et `add_handler_with_state` utilise `routing::get(handler)`. Il faut `post` pour le register.
+
+### Pièges Frontend
+
+6. **Autoplay policy** : Chrome/Firefox bloquent `audio.play()` sans interaction utilisateur. La solution la plus propre est de démarrer le flux seulement après un premier clic de l'utilisateur (bouton "Activer WebRenderer" ou premier clic sur Play).
+
+7. **Reconnexion et header FLAC** : Si le navigateur recharge la page, la `stream_url` est la même. La `StreamingFlacSink` envoie le header FLAC caché aux late-joiners via `register_client()`. Tester que cette mécanique fonctionne correctement quand le pipeline est en cours de lecture.
+
+8. **Suppression de `filterRenderers`** : La fonction `filterRenderers` dans `UnifiedControlView.vue` utilise `model_name === "WebRenderer"` et `renderer.id === myUdn`. Ces valeurs viennent de `RendererInfo` retourné par WebSocket. Dans la nouvelle architecture, le renderer UPnP est toujours créé avec `model_name = "WebRenderer"` (à conserver dans `WebRendererFactory`). L'UDN reste `uuid:{instance_id}`. Le filtre continuera de fonctionner si `rendererInfo.value.udn` est correctement alimenté depuis la réponse du `POST /register` ou du SSE.
+
+---
+
+### Critical Files for Implementation
+
+- `/Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmowebrenderer/src/websocket.rs` - Logique de création de device UPnP à reprendre dans `registry.rs` et `register.rs` ; contient aussi `register_with_control_point` et `update_*_vars` à migrer
+- `/Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmoaudio-ext/src/sinks/streaming_flac_sink.rs` - Infrastructure principale réutilisée : `StreamingFlacSink::new()`, `StreamHandle::subscribe_flac()`, gestion header cache et auto_stop
+- `/Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmoaudio-ext/src/sources/playlist_source.rs` - Modèle pour `source_loader.rs` : pattern `decode_and_emit_track`, gestion EOF, envoi `AudioSegment` vers children
+- `/Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmomediaserver/src/paradise_streaming.rs` - Pattern exact du handler HTTP streaming à copier dans `stream.rs` : headers, `Body::from_stream(ReaderStream::new(stream))`
+- `/Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmoapp/webapp/src/composables/useWebRenderer.ts` - Toute la logique frontend à remplacer : `GaplessEngine`, WebSocket, `connect()`, `execCommand()`, `handleMessage()` — remplacer par `fetch POST /register` + `<audio src=streamUrl>`
diff --git a/Blackboard/ToThinkAbout/webrenderer_server_side_streaming.md b/Blackboard/ToThinkAbout/webrenderer_server_side_streaming.md
new file mode 100644
index 00000000..4706b82a
--- /dev/null
+++ b/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`.
diff --git a/Cargo.lock b/Cargo.lock
index 262722b5..fe7c03f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "PMOMusic"
-version = "0.3.20"
+version = "0.3.23"
 dependencies = [
  "axum 0.8.7",
  "console-subscriber",
@@ -1700,6 +1700,24 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "fdk-aac"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb67e142688083cb9afb63f2424203fc98c4e7afb494bf912b60b55513b177e"
+dependencies = [
+ "fdk-aac-sys",
+]
+
+[[package]]
+name = "fdk-aac-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24516d2611506d5cb1833555adc75f6baf9fe2706b9c13e6fc33a6b22c51ca83"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.5"
@@ -3863,6 +3881,7 @@ version = "0.1.0"
 dependencies = [
  "async-trait",
  "bytes",
+ "futures",
  "pmoaudio",
  "pmoaudiocache",
  "pmocache",
@@ -3871,6 +3890,7 @@ dependencies = [
  "pmometadata",
  "pmoplaylist",
  "rand 0.8.5",
+ "reqwest",
  "serde",
  "serde_json",
  "tokio",
@@ -4041,6 +4061,7 @@ version = "0.1.0"
 dependencies = [
  "bytes",
  "claxon",
+ "fdk-aac",
  "lewton",
  "libc",
  "libflac-sys",
@@ -4359,19 +4380,26 @@ dependencies = [
  "async-trait",
  "axum 0.8.7",
  "axum-extra",
+ "bytes",
  "futures",
  "parking_lot",
+ "pmoaudio",
+ "pmoaudio-ext",
  "pmoconfig",
  "pmocontrol",
  "pmodidl",
+ "pmoflac",
  "pmomediarenderer",
+ "pmometadata",
  "pmoserver",
  "pmoupnp",
  "pmoutils",
+ "reqwest",
  "serde",
  "serde_json",
  "thiserror 2.0.17",
  "tokio",
+ "tokio-util",
  "tower-http",
  "tracing",
  "uuid",
diff --git a/Cargo.toml b/Cargo.toml
index 9b5fb4cd..fd97a8da 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ members = [
     "pmocovers",
     "pmoaudiocache",
     "pmoaudio",
+    "pmoaudio-ext",
     "pmoqobuz",
     "pmoparadise",
     "pmoradiofrance",
diff --git a/PMOMusic/Cargo.toml b/PMOMusic/Cargo.toml
index 1f499509..07676aaf 100644
--- a/PMOMusic/Cargo.toml
+++ b/PMOMusic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "PMOMusic"
-version = "0.3.22"
+version = "0.3.23"
 edition = "2024"
 
 [dependencies]
diff --git a/pmoapp/webapp/src/composables/useWebRenderer.ts b/pmoapp/webapp/src/composables/useWebRenderer.ts
index 4c85c056..6255ed8e 100644
--- a/pmoapp/webapp/src/composables/useWebRenderer.ts
+++ b/pmoapp/webapp/src/composables/useWebRenderer.ts
@@ -1,85 +1,25 @@
 /**
  * Composable pour gérer le WebRenderer navigateur.
  *
- * Se connecte automatiquement au WebSocket /api/webrenderer/ws au montage
- * et se déconnecte proprement au démontage ou à la fermeture de la page.
+ * S'enregistre via POST /api/webrenderer/register au montage
+ * et diffuse l'audio via un élément <audio> pointant sur
+ * /api/webrenderer/{id}/stream (flux FLAC encodé côté serveur).
  *
- * Le navigateur est ainsi vu comme un renderer UPnP par le ControlPoint.
- * L'audio est géré via deux éléments <audio> en ping-pong connectés à un
- * AudioContext (MediaElementSourceNode) pour le contrôle du volume/mute.
+ * Le navigateur est vu comme un renderer UPnP par le ControlPoint.
+ * Le gapless est géré côté serveur : le navigateur lit un flux continu.
  *
- * ## Flux gapless
- * 1. SetAVTransportURI(N)     → slotA.src = N, slotA.load()
- * 2. Play                     → slotA.play()
- * 3. SetNextAVTransportURI(N+1) → slotB.src = N+1, slotB.load() (préchargement)
- * 4. slotA "ended"            → currentSlot = B, slotB.play() immédiat
- *                               → TrackEnded envoyé au backend
- * 5. Cycle recommence depuis 3 (slotA redevient le "next")
+ * Cycle de vie du flux audio :
+ * - PLAYING/TRANSITIONING → src = stream_url + play()  (nouvelle connexion HTTP)
+ * - PAUSED/STOPPED        → pause() + src = ""          (déconnexion HTTP)
  */
 
 import { ref, onMounted, onUnmounted, readonly } from "vue";
-
-// ─── Types (miroir de messages.rs) ────────────────────────────────────────────
-
-interface BrowserCapabilities {
-    instance_id: string;
-    user_agent: string;
-    supported_formats: string[];
-}
-
-interface RendererInfo {
-    udn: string;
-    friendly_name: string;
-    model_name: string;
-    description_url: string;
-}
-
-type TransportAction = "play" | "pause" | "stop" | "seek" | "set_uri" | "set_next_uri";
-
-interface CommandParams {
-    uri?: string;
-    metadata?: string;
-    position?: string;
-}
-
-interface StateSyncMessage {
-    type: "state_sync";
-    current_uri?: string;
-    current_metadata?: string;
-    next_uri?: string;
-    next_metadata?: string;
-    playback_state: PlaybackState;
-    position?: string;
-    volume: number;
-    mute: boolean;
-}
-
-type ServerMessage =
-    | { type: "session_created"; token: string; renderer_info: RendererInfo }
-    | StateSyncMessage
-    | { type: "command"; action: TransportAction; params?: CommandParams }
-    | { type: "set_volume"; volume: number }
-    | { type: "set_mute"; mute: boolean }
-    | { type: "ping" };
-
-type PlaybackState = "PLAYING" | "PAUSED" | "STOPPED" | "TRANSITIONING";
-
-type ClientMessage =
-    | { type: "init"; capabilities: BrowserCapabilities }
-    | { type: "state_update"; state: PlaybackState }
-    | { type: "position_update"; position: string; duration: string }
-    | { type: "volume_update"; volume: number; mute: boolean }
-    | { type: "track_ended" }
-    | { type: "pong" };
+import { sse } from "../services/pmocontrol/sse";
 
 // ─── Identifiant stable de l'instance navigateur ─────────────────────────────
 
 const INSTANCE_ID_KEY = "pmomusic_webrenderer_instance_id";
 
-/**
- * Génère un UUID v4. Utilise crypto.randomUUID() si disponible (HTTPS/localhost),
- * sinon fallback sur crypto.getRandomValues() (disponible partout, y compris HTTP).
- */
 function generateUUID(): string {
     if (typeof crypto.randomUUID === "function") {
         return crypto.randomUUID();
@@ -92,10 +32,6 @@ function generateUUID(): string {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
-/**
- * Retourne un UUID stable pour cette instance navigateur.
- * Généré une fois, persisté en localStorage, réutilisé entre les reloads.
- */
 function getOrCreateInstanceId(): string {
     try {
         let id = localStorage.getItem(INSTANCE_ID_KEY);
@@ -105,496 +41,221 @@ function getOrCreateInstanceId(): string {
         }
         return id;
     } catch {
-        // localStorage unavailable (private mode, etc.) → use a session-scoped UUID
         return generateUUID();
     }
 }
 
-// ─── Détection des formats supportés ─────────────────────────────────────────
+// ─── Types ────────────────────────────────────────────────────────────────────
 
-function getSupportedFormats(): string[] {
-    const audio = document.createElement("audio");
-    const formats: Array<[string, string]> = [
-        ["mp3", "audio/mpeg"],
-        ["flac", "audio/flac"],
-        ["ogg", "audio/ogg; codecs=vorbis"],
-        ["opus", "audio/ogg; codecs=opus"],
-        ["aac", "audio/aac"],
-        ["wav", "audio/wav"],
-        ["m4a", 'audio/mp4; codecs="mp4a.40.2"'],
-        ["webm", "audio/webm"],
-    ];
-    return formats
-        .filter(([, mime]) => audio.canPlayType(mime) !== "")
-        .map(([fmt]) => fmt);
+interface RegisterRequest {
+    instance_id: string;
+    user_agent: string;
 }
 
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function secondsToUpnpTime(s: number): string {
-    const h = Math.floor(s / 3600);
-    const m = Math.floor((s % 3600) / 60);
-    const sec = Math.floor(s % 60);
-    return `${h}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
-}
-
-function upnpTimeToSeconds(t: string): number {
-    const parts = t.split(":").map(Number);
-    if (parts.length !== 3) return 0;
-    const [h, m, s] = parts;
-    return (h ?? 0) * 3600 + (m ?? 0) * 60 + (s ?? 0);
-}
-
-// ─── Moteur Audio (HTMLAudioElement + MediaElementSourceNode) ─────────────────
-
-class GaplessEngine {
-    /** Les deux éléments <audio> fixes (ping-pong) */
-    private readonly slots: [HTMLAudioElement, HTMLAudioElement];
-
-    /** Index du slot actuellement en lecture (0 ou 1) */
-    private currentSlot: 0 | 1 = 0;
-    /** URI préchargée dans le slot "next" (l'autre) */
-    private nextUri: string | null = null;
-
-    private volume = 1.0;
-    private muted = false;
-
-    /** Durée de la piste courante (secondes), lue via loadedmetadata */
-    private _duration = 0;
-
-    /**
-     * Indique qu'un play() a été reçu avant set_uri (race condition).
-     * setCurrent() le détectera et lancera la lecture automatiquement.
-     */
-    private playPending = false;
-
-    onStateChange: (state: PlaybackState) => void = () => {};
-    onPosition: (pos: number, dur: number) => void = () => {};
-    onTrackEnded: () => void = () => {};
-
-    private positionInterval: ReturnType<typeof setInterval> | null = null;
-
-    constructor() {
-        this.slots = [
-            this.makeAudioElement(),
-            this.makeAudioElement(),
-        ];
-    }
-
-    // ── Volume / Mute ────────────────────────────────────────────────────────
-
-    setVolume(v: number) {
-        this.volume = v;
-        for (const el of this.slots) {
-            el.volume = this.muted ? 0 : v;
-        }
-    }
-
-    setMute(m: boolean) {
-        this.muted = m;
-        for (const el of this.slots) {
-            el.volume = m ? 0 : this.volume;
-        }
-    }
-
-    // ── Transport ────────────────────────────────────────────────────────────
-
-    /** Charge la piste courante (sans la jouer). */
-    setCurrent(uri: string): void {
-        this.nextUri = null;
-        this.onStateChange("TRANSITIONING");
-        this._loadCurrent(uri);
-
-        // Si play() est arrivé avant set_uri (race condition), lancer la lecture maintenant
-        if (this.playPending) {
-            this.playPending = false;
-            this.play().catch((e) =>
-                console.error("[GaplessEngine] deferred play() failed:", e),
-            );
-        }
-    }
-
-    /**
-     * Restaure l'état audio après un reload sans notifier le serveur de TRANSITIONING.
-     * Le serveur connaît déjà l'état ; on recharge juste l'audio localement.
-     * Si shouldPlay=true mais que l'autoplay est bloqué, on notifie PAUSED
-     * pour que l'interface puisse proposer un bouton Play fonctionnel.
-     */
-    async syncRestore(currentUri: string, nextUri: string | undefined, shouldPlay: boolean): Promise<void> {
-        this._loadCurrent(currentUri);
-        if (nextUri) {
-            this.setNext(nextUri);
-        }
-        if (shouldPlay) {
-            try {
-                await this.play();
-                // play() a réussi : onStateChange("PLAYING") a déjà été appelé dans play()
-            } catch {
-                // Autoplay bloqué par le navigateur : signaler PAUSED au serveur
-                // L'audio est chargé, un clic Play suffira à démarrer
-                this.onStateChange("PAUSED");
-            }
-        }
-    }
-
-    private _loadCurrent(uri: string): void {
-        const el = this.slots[this.currentSlot];
-        // Retirer l'écouteur "ended" de l'autre slot si présent
-        const otherSlot = (1 - this.currentSlot) as 0 | 1;
-        this.slots[otherSlot].onended = null;
-        this.slots[otherSlot].pause();
-
-        el.onended = null;
-        el.pause();
-        el.src = uri;
-        el.load();
-
-        // Récupérer la durée dès que les métadonnées sont disponibles
-        el.onloadedmetadata = () => {
-            this._duration = el.duration || 0;
-        };
-    }
-
-    /** Précharge la piste suivante dans l'autre slot. */
-    setNext(uri: string): void {
-        this.nextUri = uri;
-        const nextSlot = (1 - this.currentSlot) as 0 | 1;
-        const el = this.slots[nextSlot];
-        el.src = uri;
-        el.preload = "auto";
-        el.load();
-    }
-
-    async play(): Promise<void> {
-        const el = this.slots[this.currentSlot];
-
-        // Si pas de source : play() est arrivé avant set_uri (race condition).
-        // On mémorise et setCurrent() déclenchera la lecture dès qu'il sera appelé.
-        if (!el.src || el.src === window.location.href) {
-            this.playPending = true;
-            return;
-        }
-
-        this.playPending = false;
-        el.onended = () => this.onCurrentEnded();
-
-        // Si l'élément n'a pas encore de données, attendre canplay.
-        if (el.readyState < HTMLMediaElement.HAVE_FUTURE_DATA) {
-            await new Promise<void>((resolve) => {
-                const onCanPlay = () => {
-                    el.removeEventListener("canplay", onCanPlay);
-                    resolve();
-                };
-                el.addEventListener("canplay", onCanPlay);
-            });
-        }
-
-        try {
-            await el.play();
-        } catch (e) {
-            console.warn("[GaplessEngine] play() failed (autoplay blocked?):", e);
-            throw e;
-        }
-
-        this.startPositionTimer();
-        this.onStateChange("PLAYING");
-    }
-
-    pause(): void {
-        const el = this.slots[this.currentSlot];
-        el.pause();
-        this.stopPositionTimer();
-        this.onStateChange("PAUSED");
-        this.sendPosition();
-    }
-
-    stop(): void {
-        this.playPending = false;
-        const el = this.slots[this.currentSlot];
-        el.onended = null;
-        el.pause();
-        el.currentTime = 0;
-        this.nextUri = null;
-        this.stopPositionTimer();
-        this.onStateChange("STOPPED");
-    }
-
-    seek(toSeconds: number): void {
-        const el = this.slots[this.currentSlot];
-        el.currentTime = toSeconds;
-    }
-
-    destroy(): void {
-        this.stopPositionTimer();
-        for (const el of this.slots) {
-            el.onended = null;
-            el.pause();
-            el.src = "";
-        }
-    }
-
-    // ── Privé ────────────────────────────────────────────────────────────────
-
-    private makeAudioElement(): HTMLAudioElement {
-        const el = document.createElement("audio");
-        el.preload = "auto";
-        return el;
-    }
-
-    private onCurrentEnded(): void {
-        const nextSlot = (1 - this.currentSlot) as 0 | 1;
-
-        if (this.nextUri !== null) {
-            // Le slot suivant est préchargé, on bascule
-            this.currentSlot = nextSlot;
-            this.nextUri = null;
-            this._duration = 0;
-
-            const nextEl = this.slots[this.currentSlot];
-            nextEl.onended = () => this.onCurrentEnded();
-
-            // Récupérer la durée de la nouvelle piste courante
-            if (nextEl.duration && isFinite(nextEl.duration)) {
-                this._duration = nextEl.duration;
-            } else {
-                nextEl.onloadedmetadata = () => {
-                    this._duration = nextEl.duration || 0;
-                };
-            }
-
-            // Informer le backend (qui fera le swap current←next côté serveur)
-            this.onTrackEnded();
-
-            // Démarrer immédiatement (le préchargement a eu lieu)
-            nextEl.play().catch((e) =>
-                console.error("[GaplessEngine] next.play() failed:", e),
-            );
-            // L'état reste PLAYING
-        } else {
-            // Pas de suivant : fin de lecture
-            this.stopPositionTimer();
-            this.onStateChange("STOPPED");
-            this.onTrackEnded();
-        }
-    }
-
-    private startPositionTimer(): void {
-        if (this.positionInterval !== null) return;
-        this.positionInterval = setInterval(() => this.sendPosition(), 1000);
-    }
-
-    private stopPositionTimer(): void {
-        if (this.positionInterval !== null) {
-            clearInterval(this.positionInterval);
-            this.positionInterval = null;
-        }
-    }
-
-    private sendPosition(): void {
-        const el = this.slots[this.currentSlot];
-        const pos = el.currentTime || 0;
-        const dur = (el.duration && isFinite(el.duration)) ? el.duration : this._duration;
-        this.onPosition(pos, dur);
-    }
+interface RegisterResponse {
+    stream_url: string;
+    udn: string;
 }
 
 // ─── Composable ───────────────────────────────────────────────────────────────
 
 export function useWebRenderer() {
     const connected = ref(false);
-    const rendererInfo = ref<RendererInfo | null>(null);
+    const streamUrl = ref<string | null>(null);
+    /** UDN du device UPnP créé côté serveur pour ce navigateur */
+    const rendererUdn = ref<string | null>(null);
 
-    let ws: WebSocket | null = null;
-    let engine: GaplessEngine | null = null;
+    let audioEl: HTMLAudioElement | null = null;
+    let instanceId: string | null = null;
+    let currentStreamUrl: string | null = null;
     let onConnectedCallback: (() => void) | null = null;
+    let sseUnsubscribe: (() => void) | null = null;
+    let pendingCanPlay: (() => void) | null = null;
 
-    // ── Envoi d'un message au backend ────────────────────────────────────────
+    // ── Connexion / déconnexion du flux audio ─────────────────────────────────
 
-    function send(msg: ClientMessage) {
-        if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(msg));
+    function startStream(): void {
+        console.log("[WebRenderer] startStream called, audioEl=", !!audioEl, "currentStreamUrl=", currentStreamUrl);
+        if (!audioEl || !currentStreamUrl) return;
+        const el = audioEl;
+        // Si le stream est en erreur (networkState=3), réinitialiser avant de réessayer
+        if (el.networkState === 3 /* NETWORK_NO_SOURCE */ && !pendingCanPlay) {
+            console.log("[WebRenderer] startStream: networkState=3, resetting before retry");
+            el.removeAttribute("src");
+            el.load();
         }
-    }
-
-    // ── Initialisation du moteur ──────────────────────────────────────────────
-
-    function initEngine(): GaplessEngine {
-        const e = new GaplessEngine();
-
-        e.onStateChange = (state) => {
-            send({ type: "state_update", state });
-        };
-
-        e.onPosition = (pos, dur) => {
-            send({
-                type: "position_update",
-                position: secondsToUpnpTime(pos),
-                duration: secondsToUpnpTime(dur),
-            });
-        };
-
-        e.onTrackEnded = () => {
-            send({ type: "track_ended" });
-        };
-
-        return e;
-    }
-
-    // ── Exécution des commandes UPnP ──────────────────────────────────────────
-
-    async function execCommand(action: TransportAction, params?: CommandParams) {
-        if (!engine) return;
-
-        switch (action) {
-            case "set_uri":
-                if (params?.uri) {
-                    engine.setCurrent(params.uri);
-                }
-                break;
-
-            case "set_next_uri":
-                if (params?.uri) {
-                    engine.setNext(params.uri);
-                }
-                break;
-
-            case "play":
-                await engine.play().catch((e) =>
-                    console.warn("[WebRenderer] play() failed:", e),
-                );
-                break;
-
-            case "pause":
-                engine.pause();
-                break;
-
-            case "stop":
-                engine.stop();
-                break;
-
-            case "seek":
-                if (params?.position) {
-                    engine.seek(upnpTimeToSeconds(params.position));
-                }
-                break;
-        }
-    }
-
-    // ── Gestion des messages entrants ─────────────────────────────────────────
-
-    function handleMessage(event: MessageEvent) {
-        let msg: ServerMessage;
-        try {
-            msg = JSON.parse(event.data as string) as ServerMessage;
-        } catch {
-            console.warn("[WebRenderer] Message non-JSON reçu :", event.data);
+        // Si le stream est déjà chargé/en cours, ne pas réouvrir la connexion HTTP.
+        // (évite que PLAYING après TRANSITIONING ne crée un nouveau pipe)
+        if (el.hasAttribute("src") && (el.readyState > 0 || pendingCanPlay)) {
+            console.log("[WebRenderer] startStream: stream already open, ignoring (readyState=", el.readyState, ")");
             return;
         }
-
-        switch (msg.type) {
-            case "session_created":
-                rendererInfo.value = msg.renderer_info;
-                connected.value = true;
-                onConnectedCallback?.();
-                break;
-
-            case "state_sync":
-                if (engine && msg.current_uri) {
-                    engine.setVolume(msg.volume / 100);
-                    engine.setMute(msg.mute);
-                    const shouldPlay = msg.playback_state === "PLAYING" || msg.playback_state === "TRANSITIONING";
-                    // syncRestore recharge l'audio sans notifier le serveur de l'état
-                    // (le serveur connaît déjà l'état ; on évite un aller-retour TRANSITIONING)
-                    engine.syncRestore(msg.current_uri, msg.next_uri, shouldPlay);
-                }
-                break;
-
-            case "command":
-                void execCommand(msg.action, msg.params);
-                break;
-
-            case "set_volume":
-                engine?.setVolume(msg.volume / 100);
-                break;
-
-            case "set_mute":
-                engine?.setMute(msg.mute);
-                break;
-
-            case "ping":
-                send({ type: "pong" });
-                break;
+        // Sur Safari, play() échoue avec NotSupportedError si appelé avant que
+        // l'élément audio ait reçu assez de données (readyState < HAVE_FUTURE_DATA).
+        // On attend canplay avant d'appeler play().
+        if (pendingCanPlay) {
+            el.removeEventListener("canplay", pendingCanPlay);
         }
-    }
+        el.src = currentStreamUrl;
+        console.log("[WebRenderer] src set, readyState=", el.readyState, "networkState=", el.networkState);
 
-    // ── Connexion ─────────────────────────────────────────────────────────────
+        el.addEventListener("error", () => {
+            console.error("[WebRenderer] event:error code=", el.error?.code, el.error?.message,
+                "readyState=", el.readyState, "networkState=", el.networkState);
+            // Nettoyer pendingCanPlay pour permettre un retry au prochain PLAYING/TRANSITIONING
+            if (pendingCanPlay) {
+                el.removeEventListener("canplay", pendingCanPlay);
+                pendingCanPlay = null;
+            }
+        }, { once: true });
+        el.addEventListener("loadstart",      () => console.debug("[WebRenderer] event:loadstart readyState=", el.readyState), { once: true });
+        el.addEventListener("loadedmetadata", () => console.debug("[WebRenderer] event:loadedmetadata readyState=", el.readyState), { once: true });
+        el.addEventListener("loadeddata",     () => console.debug("[WebRenderer] event:loadeddata readyState=", el.readyState), { once: true });
+        el.addEventListener("progress",       () => console.debug("[WebRenderer] event:progress readyState=", el.readyState), { once: true });
+        el.addEventListener("stalled",        () => console.warn("[WebRenderer] event:stalled readyState=", el.readyState, "networkState=", el.networkState));
+        el.addEventListener("waiting",        () => console.warn("[WebRenderer] event:waiting readyState=", el.readyState));
+        el.addEventListener("suspend",        () => console.debug("[WebRenderer] event:suspend readyState=", el.readyState, "networkState=", el.networkState), { once: true });
+        el.addEventListener("abort",          () => console.warn("[WebRenderer] event:abort"), { once: true });
+        el.addEventListener("emptied",        () => console.warn("[WebRenderer] event:emptied"), { once: true });
 
-    function connect() {
-        if (ws) return;
-
-        const protocol = location.protocol === "https:" ? "wss:" : "ws:";
-        const url = `${protocol}//${location.host}/api/webrenderer/ws`;
-        ws = new WebSocket(url);
-
-        ws.onopen = () => {
-            send({
-                type: "init",
-                capabilities: {
-                    instance_id: getOrCreateInstanceId(),
-                    user_agent: navigator.userAgent,
-                    supported_formats: getSupportedFormats(),
-                },
+        const onCanPlay = () => {
+            console.log("[WebRenderer] event:canplay readyState=", el.readyState, "calling play()");
+            pendingCanPlay = null;
+            el.removeEventListener("canplay", onCanPlay);
+            el.play().then(() => {
+                console.log("[WebRenderer] play() resolved OK");
+            }).catch((e: unknown) => {
+                console.warn("[WebRenderer] play() rejected:", e);
             });
         };
-
-        ws.onmessage = handleMessage;
-
-        ws.onclose = () => {
-            connected.value = false;
-            rendererInfo.value = null;
-            ws = null;
-        };
-
-        ws.onerror = (err) => {
-            console.error("[WebRenderer] Erreur WebSocket :", err);
-        };
+        pendingCanPlay = onCanPlay;
+        el.addEventListener("canplay", onCanPlay);
     }
 
-    // ── Déconnexion ───────────────────────────────────────────────────────────
-
-    function disconnect() {
-        engine?.destroy();
-        if (ws) {
-            ws.close(1000, "Page unloaded");
-            ws = null;
+    function stopStream(): void {
+        console.log("[WebRenderer] stopStream called, readyState=", audioEl?.readyState);
+        if (!audioEl) return;
+        if (pendingCanPlay) {
+            audioEl.removeEventListener("canplay", pendingCanPlay);
+            pendingCanPlay = null;
         }
-        connected.value = false;
+        audioEl.pause();
+        audioEl.removeAttribute("src");  // ferme la connexion HTTP (src="" résolu comme URL de page sur Safari)
+        audioEl.load();  // force le reset de l'état réseau
+    }
+
+    // ── Enregistrement ────────────────────────────────────────────────────────
+
+    async function register(): Promise<void> {
+        instanceId = getOrCreateInstanceId();
+
+        const body: RegisterRequest = {
+            instance_id: instanceId,
+            user_agent: navigator.userAgent,
+        };
+
+        try {
+            const resp = await fetch("/api/webrenderer/register", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+
+            if (!resp.ok) {
+                console.error("[WebRenderer] register failed:", resp.status);
+                return;
+            }
+
+            const data = (await resp.json()) as RegisterResponse;
+            streamUrl.value = data.stream_url;
+            currentStreamUrl = data.stream_url;
+            rendererUdn.value = data.udn;
+            connected.value = true;
+            onConnectedCallback?.();
+
+            // S'abonner aux événements SSE du renderer pour piloter la lecture
+            sse.connect();
+            const udn = data.udn;
+            sseUnsubscribe?.();
+            sseUnsubscribe = sse.onRendererEvent((event) => {
+                if (event.renderer_id !== udn) return;
+                if (event.type !== "state_changed") return;
+
+                const state = event.state;
+                console.log("[WebRenderer] SSE state_changed →", state, "| event.renderer_id=", event.renderer_id, "udn=", udn, "| audioEl.src=", audioEl?.src, "readyState=", audioEl?.readyState, "networkState=", audioEl?.networkState, "pendingCanPlay=", !!pendingCanPlay);
+                if (state === "PLAYING" || state === "TRANSITIONING") {
+                    startStream();
+                } else if (state === "PAUSED" || state === "STOPPED") {
+                    stopStream();
+                }
+            });
+        } catch (e) {
+            console.error("[WebRenderer] register error:", e);
+        }
+    }
+
+    // ── Désenregistrement ─────────────────────────────────────────────────────
+
+    async function unregister(): Promise<void> {
+        if (!instanceId) return;
+        try {
+            await fetch(`/api/webrenderer/${instanceId}`, { method: "DELETE" });
+        } catch {
+            // Ignoré lors du déchargement de page
+        }
+        instanceId = null;
+    }
+
+    // ── Volume / Mute ─────────────────────────────────────────────────────────
+
+    function setVolume(v: number): void {
+        if (audioEl) audioEl.volume = v;
+    }
+
+    function setMute(m: boolean): void {
+        if (audioEl) audioEl.muted = m;
     }
 
     // ── Cycle de vie ──────────────────────────────────────────────────────────
 
     onMounted(() => {
-        engine = initEngine();
-        connect();
-        window.addEventListener("beforeunload", disconnect);
+        audioEl = document.createElement("audio");
+        audioEl.preload = "auto";
+        document.body.appendChild(audioEl);
+
+        void register();
+        window.addEventListener("beforeunload", () => void unregister());
     });
 
     onUnmounted(() => {
-        disconnect();
-        engine = null;
-        window.removeEventListener("beforeunload", disconnect);
+        sseUnsubscribe?.();
+        sseUnsubscribe = null;
+        stopStream();
+        void unregister();
+        if (audioEl) {
+            audioEl.remove();
+            audioEl = null;
+        }
+        connected.value = false;
+        streamUrl.value = null;
+        rendererUdn.value = null;
+        window.removeEventListener("beforeunload", () => void unregister());
     });
 
     // ── API publique ──────────────────────────────────────────────────────────
 
     return {
-        /** true quand la session WebRenderer est établie */
+        /** true quand l'instance est enregistrée sur le serveur */
         connected: readonly(connected),
-        /** Infos du renderer UPnP créé pour ce navigateur */
-        rendererInfo: readonly(rendererInfo),
-        /** Callback appelé quand la session est créée (pour rafraîchir la liste des renderers) */
+        /** URL du flux FLAC servi par le serveur */
+        streamUrl: readonly(streamUrl),
+        /** UDN du device UPnP créé pour ce navigateur (null avant enregistrement) */
+        rendererUdn: readonly(rendererUdn),
+        /** Callback appelé quand l'enregistrement est confirmé */
         onConnected(fn: () => void) {
             onConnectedCallback = fn;
         },
+        setVolume,
+        setMute,
     };
 }
diff --git a/pmoapp/webapp/src/views/UnifiedControlView.vue b/pmoapp/webapp/src/views/UnifiedControlView.vue
index 8effc8b7..694542b2 100644
--- a/pmoapp/webapp/src/views/UnifiedControlView.vue
+++ b/pmoapp/webapp/src/views/UnifiedControlView.vue
@@ -106,7 +106,7 @@ function handleRendererSelect(rendererId: string) {
 // Filtre la liste des renderers pour exclure les WebRenderers d'autres navigateurs.
 // Seul le WebRenderer créé par ce navigateur (identifié par son UDN) reste visible.
 function filterRenderers(renderers: typeof allRenderers.value) {
-    const myUdn = webRenderer.rendererInfo.value?.udn ?? null;
+    const myUdn = webRenderer.rendererUdn.value;
     return renderers.filter((r) => {
         if (r.model_name !== "WebRenderer") return true; // renderer classique : toujours visible
         if (myUdn === null) return false; // pas encore de session : masquer tous les WebRenderers
@@ -140,7 +140,7 @@ watch(
 
 // Watch l'UDN du WebRenderer local : quand il s'établit, resync pour faire apparaître notre onglet
 watch(
-    () => webRenderer.rendererInfo.value?.udn,
+    () => webRenderer.rendererUdn.value,
     () => {
         syncWithRenderers(filterRenderers(allRenderers.value));
     },
diff --git a/pmoaudio-ext/Cargo.toml b/pmoaudio-ext/Cargo.toml
index 1ae36392..f36fdc6b 100644
--- a/pmoaudio-ext/Cargo.toml
+++ b/pmoaudio-ext/Cargo.toml
@@ -30,10 +30,12 @@ rand = "0.8"
 bytes = { version = "1.0", optional = true }
 serde = { workspace = true, optional = true }
 serde_json = { workspace = true, optional = true }
+reqwest = { workspace = true, features = ["stream"], optional = true }
+futures = { version = "0.3", optional = true }
 
 [features]
 default = []
 cache-sink = ["dep:pmoaudiocache", "dep:pmoflac", "dep:pmometadata", "dep:serde_json"]
 playlist = ["cache-sink", "dep:pmoplaylist", "dep:pmocache"]
-http-stream = ["dep:pmoflac", "dep:pmometadata", "dep:bytes", "dep:serde"]
+http-stream = ["dep:pmoflac", "dep:pmometadata", "dep:bytes", "dep:serde", "dep:reqwest", "dep:futures"]
 all = ["cache-sink", "playlist", "http-stream"]
diff --git a/pmoaudio-ext/src/lib.rs b/pmoaudio-ext/src/lib.rs
index 3828c88d..6dfc44b8 100755
--- a/pmoaudio-ext/src/lib.rs
+++ b/pmoaudio-ext/src/lib.rs
@@ -28,7 +28,7 @@ pub mod sinks;
 #[cfg(any(feature = "cache-sink", feature = "http-stream"))]
 pub mod nodes;
 
-#[cfg(feature = "playlist")]
+#[cfg(any(feature = "playlist", feature = "http-stream"))]
 pub mod sources;
 
 // Re-exports pour faciliter l'utilisation
@@ -39,4 +39,7 @@ pub use sinks::*;
 pub use nodes::*;
 
 #[cfg(feature = "playlist")]
-pub use sources::*;
+pub use sources::PlaylistSource;
+
+#[cfg(feature = "http-stream")]
+pub use sources::UriSource;
diff --git a/pmoaudio-ext/src/sinks/broadcast_pacing.rs b/pmoaudio-ext/src/sinks/broadcast_pacing.rs
index dcf28bf2..073ffc4f 100644
--- a/pmoaudio-ext/src/sinks/broadcast_pacing.rs
+++ b/pmoaudio-ext/src/sinks/broadcast_pacing.rs
@@ -5,7 +5,7 @@
 //! - Drops frames that are late (audio_ts < elapsed)
 //! - Paces broadcast to match audio playback rate
 
-use std::time::Instant;
+use std::time::{Duration, Instant};
 use tracing::trace;
 
 /// Error returned when a frame should be skipped (too late)
@@ -13,7 +13,6 @@ use tracing::trace;
 pub struct SkipFrame;
 
 /// Manages broadcast pacing with TopZeroSync detection
-#[allow(dead_code)]
 pub struct BroadcastPacer {
     /// Start time (reset on TopZeroSync)
     start_time: Instant,
@@ -21,8 +20,6 @@ pub struct BroadcastPacer {
     max_lead_time: f64,
     /// Label for logging (e.g., "FLAC" or "OGG")
     label: String,
-    /// Pending reset flag - will reset timer on next chunk
-    pending_reset: bool,
 }
 
 impl BroadcastPacer {
@@ -37,24 +34,37 @@ impl BroadcastPacer {
             start_time: Instant::now(),
             max_lead_time: max_lead_time.max(0.0),
             label: label.into(),
-            pending_reset: false,
         }
     }
 
-    /// Check timing and apply pacing - NO-OP VERSION
+    /// Reset the pacer clock (call when audio timestamp resets to 0).
+    pub fn reset(&mut self) {
+        self.start_time = Instant::now();
+        trace!("{} broadcaster: pacer reset", self.label);
+    }
+
+    /// Check timing and apply pacing.
     ///
-    /// Pacing is now handled entirely by the expiration-based system in
-    /// TimedBroadcast. This method is kept for backward compatibility
-    /// but always returns Ok(()).
-    ///
-    /// # Returns
-    ///
-    /// - Always returns `Ok(())`
+    /// If the audio is ahead of real time by more than `max_lead_time`, sleeps
+    /// until the lead is within bounds.  Returns `Err(SkipFrame)` if the chunk
+    /// is already late (audio_ts < elapsed - 1s grace).
     pub async fn check_and_pace(&mut self, audio_timestamp: f64) -> Result<(), SkipFrame> {
-        trace!(
-            "{} broadcaster: check_and_pace called with audio_ts={:.3}s (no-op - pacing handled by TimedBroadcast)",
-            self.label, audio_timestamp
-        );
+        if self.max_lead_time <= 0.0 {
+            return Ok(());
+        }
+
+        let elapsed = self.start_time.elapsed().as_secs_f64();
+        let lead = audio_timestamp - elapsed;
+
+        if lead > self.max_lead_time {
+            let sleep_secs = lead - self.max_lead_time;
+            trace!(
+                "{} broadcaster: audio ahead by {:.3}s, sleeping {:.3}s",
+                self.label, lead, sleep_secs
+            );
+            tokio::time::sleep(Duration::from_secs_f64(sleep_secs)).await;
+        }
+
         Ok(())
     }
 }
diff --git a/pmoaudio-ext/src/sinks/direct_flac_sink.rs b/pmoaudio-ext/src/sinks/direct_flac_sink.rs
new file mode 100644
index 00000000..3890bc8f
--- /dev/null
+++ b/pmoaudio-ext/src/sinks/direct_flac_sink.rs
@@ -0,0 +1,367 @@
+//! DirectFlacSink — nœud puits FLAC pour un seul client HTTP.
+//!
+//! Encode l'audio en FLAC (format fixe : 96 kHz / stéréo / 24 bits).
+//!
+//! # Cycle de vie
+//!
+//! - **Play** : le navigateur appelle `GET /stream`. `connect()` crée un nouveau
+//!   canal PCM + pipe duplex + encodeur FLAC, installe le sender dans le sink,
+//!   et notifie le sink via `client_notify`. Le flux reste ouvert : les morceaux
+//!   s'enchaînent en gapless.
+//! - **Stop** : le navigateur ferme la connexion. Le pipe se rompt, l'encodeur
+//!   s'arrête. Le sink voit `pcm_tx.send()` échouer, passe le sender à `None`,
+//!   et **bloque** sur `client_notify` jusqu'au prochain Play.
+//!   Cela bloque la source et préserve la backpressure.
+//! - **Play suivant** : `connect()` → nouveau pipe → `client_notify.notify_one()`
+//!   → le sink se débloque et reprend la consommation des segments.
+//!
+//! # Architecture
+//!
+//! ```text
+//! AudioSegment I24 @ 96 kHz
+//!     ↓ NodeLogic::process()  [bloque si pas de client]
+//! chunk_to_pcm_bytes() → PCM 24-bit LE
+//!     ↓ Arc<Mutex<Option<mpsc::Sender<PcmChunk>>>>
+//! ByteStreamReader (AsyncRead)
+//!     ↓ encode_flac_stream()
+//!     ↓ tokio::io::copy()
+//!     ↓ tokio::io::duplex pipe (256 KB)
+//!     ↓ DirectFlacStream (AsyncRead) → Body HTTP
+//! ```
+
+use std::io;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use async_trait::async_trait;
+use pmoaudio::{
+    pipeline::{AudioPipelineNode, Node, NodeLogic, PipelineHandle, StopReason},
+    AudioError, AudioSegment, SyncMarker, TypeRequirement, TypedAudioNode, _AudioSegment,
+};
+use pmoflac::{EncoderOptions, PcmFormat};
+use tokio::io::{AsyncRead, ReadBuf};
+use tokio::sync::{mpsc, watch, Mutex};
+use tokio_util::sync::CancellationToken;
+use tracing::debug;
+
+use crate::sinks::byte_stream_reader::{ByteStreamReader, PcmChunk};
+use crate::sinks::chunk_to_pcm::chunk_to_pcm_bytes;
+
+/// Format de sortie fixe du sink.
+pub const DIRECT_FLAC_SAMPLE_RATE: u32 = 96_000;
+pub const DIRECT_FLAC_CHANNELS: u8 = 2;
+pub const DIRECT_FLAC_BITS_PER_SAMPLE: u8 = 24;
+
+/// Capacité du pipe duplex (~256 KB ≈ 0.35s à 96 kHz/24 bits/stéréo).
+const PIPE_CAPACITY: usize = 256 * 1024;
+
+// ─── Shared state ─────────────────────────────────────────────────────────────
+
+type SharedPcmTx = Arc<Mutex<Option<mpsc::Sender<PcmChunk>>>>;
+
+// ─── Handle public ────────────────────────────────────────────────────────────
+
+/// Handle vers le sink, cloneable, reconnectable à chaque Play.
+#[derive(Clone)]
+pub struct DirectFlacHandle {
+    pcm_tx: SharedPcmTx,
+    /// Compteur de connexions : incrémenté à chaque connect().
+    /// Utiliser un watch channel pour éviter les notifications perdues (vs Notify).
+    client_connect_tx: Arc<watch::Sender<u64>>,
+    /// Notifie le sink interne qu'un client vient de se connecter (edge-triggered,
+    /// usage interne uniquement — le sink tourne dans le même contexte que connect()).
+    client_notify_internal: Arc<tokio::sync::Notify>,
+    /// Signale que le premier byte FLAC a été lu par le client HTTP.
+    /// `false` au démarrage / après connect(), `true` dès le premier poll_read non-vide.
+    first_byte_tx: Arc<watch::Sender<bool>>,
+    encoder_options: EncoderOptions,
+}
+
+impl DirectFlacHandle {
+    /// Crée un nouveau pipe + encodeur FLAC et retourne le flux côté lecture.
+    /// Débloque le sink s'il attendait un client.
+    pub async fn connect(&self) -> DirectFlacStream {
+        let connect_count_before = *self.client_connect_tx.borrow();
+        debug!("DirectFlacHandle::connect() called, connect_count={}", connect_count_before);
+
+        let (pcm_tx, pcm_rx) = mpsc::channel::<PcmChunk>(8);
+        let current_ts = Arc::new(tokio::sync::RwLock::new(0.0f64));
+        let current_dur = Arc::new(tokio::sync::RwLock::new(0.0f64));
+        let pcm_reader = ByteStreamReader::new(pcm_rx, current_ts, current_dur);
+
+        let (pipe_writer, pipe_reader) = tokio::io::duplex(PIPE_CAPACITY);
+
+        // Réinitialiser le signal "premier byte" AVANT de notifier le sink,
+        // pour éviter qu'une notification précédente ne se propage.
+        let _ = self.first_byte_tx.send(false);
+        debug!("DirectFlacHandle::connect() first_byte reset to false");
+
+        // Installer le nouveau sender (remplace l'éventuel ancien)
+        *self.pcm_tx.lock().await = Some(pcm_tx);
+        debug!("DirectFlacHandle::connect() pcm_tx installed");
+
+        // Incrémenter le compteur de connexions (mémorisé dans watch — pas de perte)
+        let new_count = connect_count_before.wrapping_add(1);
+        let _ = self.client_connect_tx.send(new_count);
+        debug!("DirectFlacHandle::connect() client_connect_count -> {}", new_count);
+        // Débloquer le sink interne (même contexte async → pas de race)
+        self.client_notify_internal.notify_one();
+
+        // Lancer l'encodeur en background
+        let options = self.encoder_options.clone();
+        tokio::spawn(async move {
+            debug!("DirectFlacHandle: encoder task started");
+            if let Err(e) = run_encoder(pcm_reader, pipe_writer, options).await {
+                debug!("DirectFlacStream encoder stopped: {}", e);
+            }
+            debug!("DirectFlacHandle: encoder task ended");
+        });
+
+        debug!("DirectFlacHandle::connect() returning DirectFlacStream");
+        DirectFlacStream {
+            inner: pipe_reader,
+            first_byte_tx: Some(self.first_byte_tx.clone()),
+        }
+    }
+
+    /// Retourne un receiver qui passe à `true` quand le premier byte FLAC
+    /// a été effectivement lu par le client HTTP.
+    pub fn first_byte_ready(&self) -> watch::Receiver<bool> {
+        self.first_byte_tx.subscribe()
+    }
+
+    /// Attend qu'un client HTTP se connecte (i.e. que `connect()` soit appelé).
+    /// Utilisé par `stream_source` pour retarder l'ouverture de la source
+    /// jusqu'à ce que le navigateur soit prêt à recevoir des données.
+    ///
+    /// Mémorise la valeur du compteur au moment de l'appel et attend qu'elle
+    /// augmente — ce qui garantit qu'on attend bien UNE NOUVELLE connexion,
+    /// même si `connect()` a déjà été appelé lors d'une lecture précédente.
+    pub async fn wait_for_client(&self) {
+        let seen = *self.client_connect_tx.borrow();
+        debug!("DirectFlacHandle::wait_for_client() called, seen connect_count={}", seen);
+        // subscribe() retourne un receiver dont la valeur courante est marquée "changed"
+        // donc wait_for() retourne immédiatement si la condition est déjà vraie.
+        let mut rx = self.client_connect_tx.subscribe();
+        let result = rx.wait_for(|v| {
+            debug!("DirectFlacHandle::wait_for_client() checking v={} > seen={}: {}", v, seen, *v > seen);
+            *v > seen
+        }).await;
+        debug!("DirectFlacHandle::wait_for_client() unblocked, result ok={}", result.is_ok());
+    }
+}
+
+// ─── Stream public ────────────────────────────────────────────────────────────
+
+/// Flux FLAC exposé au handler HTTP.
+///
+/// Transmet les bytes du pipe directement au client HTTP.
+/// Intercepte le premier `poll_read` non-vide pour signaler via `first_byte_tx`
+/// que des données FLAC ont effectivement été transmises au client.
+pub struct DirectFlacStream {
+    inner: tokio::io::DuplexStream,
+    /// Présent jusqu'au premier byte reçu, puis consommé (set à None).
+    first_byte_tx: Option<Arc<watch::Sender<bool>>>,
+}
+
+impl AsyncRead for DirectFlacStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let filled_before = buf.filled().len();
+        let result = Pin::new(&mut self.inner).poll_read(cx, buf);
+        if let Poll::Ready(Ok(())) = &result {
+            let filled_after = buf.filled().len();
+            if filled_after > filled_before {
+                if let Some(tx) = self.first_byte_tx.take() {
+                    debug!("DirectFlacStream: first {} bytes sent to HTTP client", filled_after - filled_before);
+                    let _ = tx.send(true);
+                }
+            }
+        }
+        result
+    }
+}
+
+// ─── Logique du nœud ─────────────────────────────────────────────────────────
+
+struct DirectFlacSinkLogic {
+    pcm_tx: SharedPcmTx,
+    client_notify: Arc<tokio::sync::Notify>,
+}
+
+#[async_trait]
+impl NodeLogic for DirectFlacSinkLogic {
+    async fn process(
+        &mut self,
+        input: Option<mpsc::Receiver<Arc<AudioSegment>>>,
+        _output: Vec<mpsc::Sender<Arc<AudioSegment>>>,
+        stop_token: CancellationToken,
+    ) -> Result<(), AudioError> {
+        let mut input = input.ok_or_else(|| {
+            AudioError::ProcessingError("DirectFlacSink requires an input".into())
+        })?;
+
+        loop {
+            tokio::select! {
+                _ = stop_token.cancelled() => {
+                    debug!("DirectFlacSink: cancelled");
+                    break;
+                }
+
+                segment = input.recv() => {
+                    match segment {
+                        None => {
+                            debug!("DirectFlacSink: input channel closed");
+                            break;
+                        }
+                        Some(seg) => match &seg.segment {
+                            _AudioSegment::Chunk(chunk) => {
+                                // Attendre un client si nécessaire (backpressure quand pas de Play)
+                                loop {
+                                    let tx_opt = self.pcm_tx.lock().await.clone();
+                                    if tx_opt.is_some() {
+                                        break;
+                                    }
+                                    // Pas de client : bloquer jusqu'à connect() ou stop
+                                    debug!("DirectFlacSink: no pcm_tx, waiting for client_notify...");
+                                    tokio::select! {
+                                        _ = stop_token.cancelled() => {
+                                            debug!("DirectFlacSink: cancelled while waiting for client");
+                                            return Ok(());
+                                        }
+                                        _ = self.client_notify.notified() => {
+                                            debug!("DirectFlacSink: client_notify received, rechecking pcm_tx");
+                                        }
+                                    }
+                                }
+
+                                let tx = self.pcm_tx.lock().await.clone().unwrap();
+                                let pcm_bytes = chunk_to_pcm_bytes(chunk, DIRECT_FLAC_BITS_PER_SAMPLE)?;
+                                let duration_sec = chunk.len() as f64 / DIRECT_FLAC_SAMPLE_RATE as f64;
+                                let pcm_chunk = PcmChunk {
+                                    bytes: pcm_bytes,
+                                    timestamp_sec: seg.timestamp_sec,
+                                    duration_sec,
+                                };
+                                if tx.send(pcm_chunk).await.is_err() {
+                                    debug!("DirectFlacSink: pcm_tx send failed (client disconnected), clearing pcm_tx");
+                                    *self.pcm_tx.lock().await = None;
+                                }
+                            }
+                            _AudioSegment::Sync(marker) => match marker.as_ref() {
+                                SyncMarker::EndOfStream => {
+                                    debug!("DirectFlacSink: EndOfStream");
+                                }
+                                _ => {}
+                            },
+                        },
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn cleanup(&mut self, _reason: StopReason) -> Result<(), AudioError> {
+        Ok(())
+    }
+}
+
+// ─── Encodeur FLAC ────────────────────────────────────────────────────────────
+
+async fn run_encoder(
+    pcm_reader: ByteStreamReader,
+    mut pipe_writer: tokio::io::DuplexStream,
+    options: EncoderOptions,
+) -> Result<(), AudioError> {
+    let format = PcmFormat {
+        sample_rate: DIRECT_FLAC_SAMPLE_RATE,
+        channels: DIRECT_FLAC_CHANNELS,
+        bits_per_sample: DIRECT_FLAC_BITS_PER_SAMPLE,
+    };
+
+    let mut flac_stream = pmoflac::encode_flac_stream(pcm_reader, format, options)
+        .await
+        .map_err(|e| AudioError::ProcessingError(format!("FLAC encoder init: {}", e)))?;
+
+    tokio::io::copy(&mut flac_stream, &mut pipe_writer)
+        .await
+        .map_err(|e| AudioError::IoError(format!("FLAC pipe copy: {}", e)))?;
+
+    flac_stream
+        .wait()
+        .await
+        .map_err(|e| AudioError::ProcessingError(format!("FLAC encoder wait: {}", e)))?;
+
+    Ok(())
+}
+
+// ─── Nœud public ─────────────────────────────────────────────────────────────
+
+pub struct DirectFlacSink {
+    inner: Node<DirectFlacSinkLogic>,
+}
+
+impl DirectFlacSink {
+    pub fn new(encoder_options: EncoderOptions) -> (Self, DirectFlacHandle) {
+        let pcm_tx: SharedPcmTx = Arc::new(Mutex::new(None));
+        let client_notify_internal = Arc::new(tokio::sync::Notify::new());
+        let (client_connect_tx, _) = watch::channel(0u64);
+        let client_connect_tx = Arc::new(client_connect_tx);
+        let (first_byte_tx, _) = watch::channel(false);
+        let first_byte_tx = Arc::new(first_byte_tx);
+
+        let logic = DirectFlacSinkLogic {
+            pcm_tx: pcm_tx.clone(),
+            client_notify: client_notify_internal.clone(),
+        };
+
+        let sink = Self {
+            inner: Node::new_with_input(logic, 16),
+        };
+
+        let handle = DirectFlacHandle {
+            pcm_tx,
+            client_connect_tx,
+            client_notify_internal,
+            first_byte_tx,
+            encoder_options,
+        };
+
+        (sink, handle)
+    }
+}
+
+#[async_trait]
+impl AudioPipelineNode for DirectFlacSink {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> {
+        self.inner.get_tx()
+    }
+
+    fn register(&mut self, _child: Box<dyn AudioPipelineNode>) {
+        panic!("DirectFlacSink is a terminal sink and cannot have children");
+    }
+
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.inner).run(stop_token).await
+    }
+
+    fn start(self: Box<Self>) -> PipelineHandle {
+        Box::new(self.inner).start()
+    }
+}
+
+impl TypedAudioNode for DirectFlacSink {
+    fn input_type(&self) -> Option<TypeRequirement> {
+        Some(TypeRequirement::any_integer())
+    }
+
+    fn output_type(&self) -> Option<TypeRequirement> {
+        None
+    }
+}
diff --git a/pmoaudio-ext/src/sinks/direct_ogg_flac_sink.rs b/pmoaudio-ext/src/sinks/direct_ogg_flac_sink.rs
new file mode 100644
index 00000000..4f94e248
--- /dev/null
+++ b/pmoaudio-ext/src/sinks/direct_ogg_flac_sink.rs
@@ -0,0 +1,574 @@
+//! DirectOggFlacSink — nœud puits OGG-FLAC pour un seul client HTTP.
+//!
+//! Combine la logique de backpressure/reconnexion de `DirectFlacSink`
+//! avec l'encodage OGG-FLAC de `StreamingOggFlacSink`.
+//!
+//! # Cycle de vie
+//!
+//! - **Play** : le navigateur appelle `GET /stream`. `connect()` crée un nouveau
+//!   canal PCM + pipe duplex + encodeur FLAC + wrapper OGG, installe le sender
+//!   dans le sink, et notifie le sink via `client_notify`. Le flux reste ouvert :
+//!   les morceaux s'enchaînent en gapless.
+//! - **Stop** : le navigateur ferme la connexion. Le pipe se rompt, l'encodeur
+//!   s'arrête. Le sink voit `pcm_tx.send()` échouer, passe le sender à `None`,
+//!   et **bloque** sur `client_notify` jusqu'au prochain Play.
+//! - **Play suivant** : `connect()` → nouveau pipe → `client_notify.notify_one()`
+//!   → le sink se débloque et reprend la consommation des segments.
+//!
+//! # Architecture
+//!
+//! ```text
+//! AudioSegment I24 @ 96 kHz
+//!     ↓ NodeLogic::process()  [bloque si pas de client]
+//! chunk_to_pcm_bytes() → PCM 24-bit LE
+//!     ↓ Arc<Mutex<Option<mpsc::Sender<PcmChunk>>>>
+//! ByteStreamReader (AsyncRead)
+//!     ↓ encode_flac_stream()
+//!     ↓ broadcast_ogg_flac_stream() → wrapping OGG pages
+//!     ↓ tokio::io::duplex pipe (256 KB)
+//!     ↓ DirectOggFlacStream (AsyncRead) → Body HTTP
+//! ```
+
+use std::io;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use pmoaudio::{
+    pipeline::{AudioPipelineNode, Node, NodeLogic, PipelineHandle, StopReason},
+    AudioError, AudioSegment, SyncMarker, TypeRequirement, TypedAudioNode, _AudioSegment,
+};
+use pmoflac::{EncoderOptions, PcmFormat};
+use tokio::io::{AsyncRead, ReadBuf};
+use tokio::sync::{mpsc, watch, Mutex};
+use tokio_util::sync::CancellationToken;
+use tracing::{debug, warn};
+
+use crate::sinks::byte_stream_reader::{ByteStreamReader, PcmChunk};
+use crate::sinks::chunk_to_pcm::chunk_to_pcm_bytes;
+use crate::sinks::flac_frame_utils::{extract_sample_rate_from_streaminfo, read_flac_header};
+
+/// Format de sortie fixe du sink.
+pub const DIRECT_OGG_FLAC_SAMPLE_RATE: u32 = 96_000;
+pub const DIRECT_OGG_FLAC_CHANNELS: u8 = 2;
+pub const DIRECT_OGG_FLAC_BITS_PER_SAMPLE: u8 = 24;
+
+/// Capacité du pipe duplex (~256 KB).
+const PIPE_CAPACITY: usize = 256 * 1024;
+
+// ─── Shared state ─────────────────────────────────────────────────────────────
+
+type SharedPcmTx = Arc<Mutex<Option<mpsc::Sender<PcmChunk>>>>;
+
+// ─── Handle public ────────────────────────────────────────────────────────────
+
+/// Handle vers le sink, cloneable, reconnectable à chaque Play.
+#[derive(Clone)]
+pub struct DirectOggFlacHandle {
+    pcm_tx: SharedPcmTx,
+    client_connect_tx: Arc<watch::Sender<u64>>,
+    client_notify_internal: Arc<tokio::sync::Notify>,
+    first_byte_tx: Arc<watch::Sender<bool>>,
+    encoder_options: EncoderOptions,
+    /// Position de lecture courante (mise à jour par ByteStreamReader).
+    current_timestamp: Arc<tokio::sync::RwLock<f64>>,
+}
+
+impl DirectOggFlacHandle {
+    /// Crée un nouveau pipe OGG-FLAC et retourne le flux côté lecture.
+    /// Débloque le sink s'il attendait un client.
+    pub async fn connect(&self) -> DirectOggFlacStream {
+        let connect_count_before = *self.client_connect_tx.borrow();
+        debug!("DirectOggFlacHandle::connect() called, connect_count={}", connect_count_before);
+
+        let (pcm_tx, pcm_rx) = mpsc::channel::<PcmChunk>(8);
+        // Réinitialiser le timestamp à 0 pour la nouvelle connexion
+        *self.current_timestamp.write().await = 0.0;
+        let current_dur = Arc::new(tokio::sync::RwLock::new(0.0f64));
+        // Partager current_timestamp avec ByteStreamReader : il sera mis à jour
+        // avec le timestamp absolu du segment audio (position dans le fichier source).
+        let pcm_reader = ByteStreamReader::new(pcm_rx, self.current_timestamp.clone(), current_dur);
+
+        let (pipe_writer, pipe_reader) = tokio::io::duplex(PIPE_CAPACITY);
+
+        let _ = self.first_byte_tx.send(false);
+        debug!("DirectOggFlacHandle::connect() first_byte reset to false");
+
+        *self.pcm_tx.lock().await = Some(pcm_tx);
+        debug!("DirectOggFlacHandle::connect() pcm_tx installed");
+
+        let new_count = connect_count_before.wrapping_add(1);
+        let _ = self.client_connect_tx.send(new_count);
+        debug!("DirectOggFlacHandle::connect() client_connect_count -> {}", new_count);
+        self.client_notify_internal.notify_one();
+
+        let options = self.encoder_options.clone();
+        let current_timestamp = self.current_timestamp.clone();
+        tokio::spawn(async move {
+            debug!("DirectOggFlacHandle: encoder+ogg task started");
+            if let Err(e) = run_ogg_encoder(pcm_reader, pipe_writer, options, current_timestamp).await {
+                debug!("DirectOggFlacStream encoder stopped: {}", e);
+            }
+            debug!("DirectOggFlacHandle: encoder+ogg task ended");
+        });
+
+        debug!("DirectOggFlacHandle::connect() returning DirectOggFlacStream");
+        DirectOggFlacStream {
+            inner: pipe_reader,
+            first_byte_tx: Some(self.first_byte_tx.clone()),
+        }
+    }
+
+    pub fn first_byte_ready(&self) -> watch::Receiver<bool> {
+        self.first_byte_tx.subscribe()
+    }
+
+    /// Retourne la position de lecture courante en secondes.
+    pub async fn current_position_sec(&self) -> f64 {
+        *self.current_timestamp.read().await
+    }
+
+    pub async fn wait_for_client(&self) {
+        let seen = *self.client_connect_tx.borrow();
+        debug!("DirectOggFlacHandle::wait_for_client() called, seen connect_count={}", seen);
+        let mut rx = self.client_connect_tx.subscribe();
+        let _ = rx.wait_for(|v| *v > seen).await;
+        debug!("DirectOggFlacHandle::wait_for_client() unblocked");
+    }
+}
+
+// ─── Stream public ────────────────────────────────────────────────────────────
+
+pub struct DirectOggFlacStream {
+    inner: tokio::io::DuplexStream,
+    first_byte_tx: Option<Arc<watch::Sender<bool>>>,
+}
+
+impl AsyncRead for DirectOggFlacStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let filled_before = buf.filled().len();
+        let result = Pin::new(&mut self.inner).poll_read(cx, buf);
+        if let Poll::Ready(Ok(())) = &result {
+            let filled_after = buf.filled().len();
+            if filled_after > filled_before {
+                if let Some(tx) = self.first_byte_tx.take() {
+                    debug!("DirectOggFlacStream: first {} bytes sent to HTTP client", filled_after - filled_before);
+                    let _ = tx.send(true);
+                }
+            }
+        }
+        result
+    }
+}
+
+// ─── Logique du nœud ─────────────────────────────────────────────────────────
+
+struct DirectOggFlacSinkLogic {
+    pcm_tx: SharedPcmTx,
+    client_notify: Arc<tokio::sync::Notify>,
+}
+
+#[async_trait]
+impl NodeLogic for DirectOggFlacSinkLogic {
+    async fn process(
+        &mut self,
+        input: Option<mpsc::Receiver<Arc<AudioSegment>>>,
+        _output: Vec<mpsc::Sender<Arc<AudioSegment>>>,
+        stop_token: CancellationToken,
+    ) -> Result<(), AudioError> {
+        let mut input = input.ok_or_else(|| {
+            AudioError::ProcessingError("DirectOggFlacSink requires an input".into())
+        })?;
+
+        loop {
+            tokio::select! {
+                _ = stop_token.cancelled() => {
+                    debug!("DirectOggFlacSink: cancelled");
+                    break;
+                }
+
+                segment = input.recv() => {
+                    match segment {
+                        None => {
+                            debug!("DirectOggFlacSink: input channel closed");
+                            break;
+                        }
+                        Some(seg) => match &seg.segment {
+                            _AudioSegment::Chunk(chunk) => {
+                                // Attendre un client si nécessaire (backpressure quand pas de Play)
+                                loop {
+                                    let tx_opt = self.pcm_tx.lock().await.clone();
+                                    if tx_opt.is_some() {
+                                        break;
+                                    }
+                                    debug!("DirectOggFlacSink: no pcm_tx, waiting for client_notify...");
+                                    tokio::select! {
+                                        _ = stop_token.cancelled() => {
+                                            debug!("DirectOggFlacSink: cancelled while waiting for client");
+                                            return Ok(());
+                                        }
+                                        _ = self.client_notify.notified() => {
+                                            debug!("DirectOggFlacSink: client_notify received, rechecking pcm_tx");
+                                        }
+                                    }
+                                }
+
+                                let tx = self.pcm_tx.lock().await.clone().unwrap();
+                                let pcm_bytes = chunk_to_pcm_bytes(chunk, DIRECT_OGG_FLAC_BITS_PER_SAMPLE)?;
+                                let duration_sec = chunk.len() as f64 / DIRECT_OGG_FLAC_SAMPLE_RATE as f64;
+                                let pcm_chunk = PcmChunk {
+                                    bytes: pcm_bytes,
+                                    timestamp_sec: seg.timestamp_sec,
+                                    duration_sec,
+                                };
+                                if tx.send(pcm_chunk).await.is_err() {
+                                    warn!(
+                                        ts = seg.timestamp_sec,
+                                        "DirectOggFlacSink: chunk dropped (client disconnected at {:.3}s), waiting for reconnect",
+                                        seg.timestamp_sec,
+                                    );
+                                    *self.pcm_tx.lock().await = None;
+                                }
+                            }
+                            _AudioSegment::Sync(marker) => match marker.as_ref() {
+                                SyncMarker::EndOfStream => {
+                                    debug!("DirectOggFlacSink: EndOfStream");
+                                }
+                                _ => {}
+                            },
+                        },
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn cleanup(&mut self, _reason: StopReason) -> Result<(), AudioError> {
+        Ok(())
+    }
+}
+
+// ─── Encodeur FLAC + wrapper OGG ─────────────────────────────────────────────
+
+async fn run_ogg_encoder(
+    pcm_reader: ByteStreamReader,
+    mut pipe_writer: tokio::io::DuplexStream,
+    options: EncoderOptions,
+    _current_timestamp: Arc<tokio::sync::RwLock<f64>>,
+) -> Result<(), AudioError> {
+    let format = PcmFormat {
+        sample_rate: DIRECT_OGG_FLAC_SAMPLE_RATE,
+        channels: DIRECT_OGG_FLAC_CHANNELS,
+        bits_per_sample: DIRECT_OGG_FLAC_BITS_PER_SAMPLE,
+    };
+
+    let mut flac_stream = pmoflac::encode_flac_stream(pcm_reader, format, options)
+        .await
+        .map_err(|e| AudioError::ProcessingError(format!("FLAC encoder init: {}", e)))?;
+
+    // Lire le header FLAC et construire les pages OGG d'en-tête
+    let flac_header = read_flac_header(&mut flac_stream).await?;
+    let sample_rate = extract_sample_rate_from_streaminfo(&flac_header)?;
+
+    let stream_serial: u32 = rand::random();
+    let mut ogg = OggPageWriter::new(stream_serial);
+
+    // Page BOS (identification OGG-FLAC)
+    let ogg_flac_id = create_ogg_flac_identification(&flac_header)?;
+    let bos_page = Bytes::from(ogg.create_page(&ogg_flac_id, true, false, false));
+
+    // Page Vorbis Comment
+    let vorbis_comment = create_empty_vorbis_comment();
+    let comment_page = Bytes::from(ogg.create_page(&vorbis_comment, false, false, false));
+
+    pipe_writer.write_all(&bos_page).await
+        .map_err(|e| AudioError::IoError(format!("OGG BOS write: {}", e)))?;
+    pipe_writer.write_all(&comment_page).await
+        .map_err(|e| AudioError::IoError(format!("OGG comment write: {}", e)))?;
+
+    // Lire les frames FLAC et les encapsuler dans des pages OGG
+    let sample_rate_f64 = sample_rate as f64;
+    let mut encoded_samples = 0u64;
+    let mut read_buffer = vec![0u8; 16384];
+    let mut accumulator: Vec<u8> = Vec::with_capacity(32768);
+
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    loop {
+        match flac_stream.read(&mut read_buffer).await {
+            Ok(0) => {
+                // EOF : page EOS finale
+                let eos_page = Bytes::from(ogg.create_page(&accumulator, false, true, false));
+                let _ = pipe_writer.write_all(&eos_page).await;
+                break;
+            }
+            Ok(n) => {
+                accumulator.extend_from_slice(&read_buffer[..n]);
+
+                loop {
+                    if accumulator.len() < 4 {
+                        break;
+                    }
+
+                    // Trouver les positions de sync FLAC
+                    let mut sync_data: Vec<(usize, u32)> = Vec::new();
+                    for i in 0..accumulator.len() - 1 {
+                        let b1 = accumulator[i];
+                        let b2 = accumulator[i + 1];
+                        if b1 == 0xFF && b2 >= 0xF8 && b2 <= 0xFE {
+                            use crate::sinks::flac_frame_utils::{validate_frame_header_crc, parse_flac_block_size};
+                            if validate_frame_header_crc(&accumulator, i) {
+                                if let Some(samples) = parse_flac_block_size(&accumulator, i) {
+                                    sync_data.push((i, samples));
+                                }
+                            }
+                        }
+                    }
+
+                    if sync_data.len() < 2 {
+                        break;
+                    }
+
+                    let first_start = sync_data[0].0;
+                    let first_samples = sync_data[0].1;
+                    let second_start = sync_data[1].0;
+
+                    if first_start != 0 {
+                        accumulator.drain(0..first_start);
+                        continue;
+                    }
+
+                    let frame: Vec<u8> = accumulator.drain(0..second_start).collect();
+
+                    encoded_samples = encoded_samples.saturating_add(first_samples as u64);
+                    ogg.add_samples(first_samples as u64);
+
+                    let ogg_page = Bytes::from(ogg.create_page(&frame, false, false, false));
+                    if pipe_writer.write_all(&ogg_page).await.is_err() {
+                        // Client déconnecté — le pipe HTTP s'est rompu
+                        warn!(
+                            samples = encoded_samples,
+                            "DirectOggFlacSink: OGG pipe broken after {} samples ({:.3}s), client disconnected",
+                            encoded_samples,
+                            encoded_samples as f64 / DIRECT_OGG_FLAC_SAMPLE_RATE as f64,
+                        );
+                        return Ok(());
+                    }
+                }
+            }
+            Err(e) => {
+                return Err(AudioError::ProcessingError(format!("FLAC read: {}", e)));
+            }
+        }
+    }
+
+    flac_stream.wait().await
+        .map_err(|e| AudioError::ProcessingError(format!("FLAC encoder wait: {}", e)))?;
+
+    Ok(())
+}
+
+// ─── OGG helpers (copiés de streaming_ogg_flac_sink) ─────────────────────────
+
+struct OggPageWriter {
+    stream_serial: u32,
+    page_sequence: u32,
+    granule_position: u64,
+}
+
+impl OggPageWriter {
+    fn new(stream_serial: u32) -> Self {
+        Self { stream_serial, page_sequence: 0, granule_position: 0 }
+    }
+
+    fn add_samples(&mut self, samples: u64) {
+        self.granule_position += samples;
+    }
+
+    fn create_page(&mut self, packet_data: &[u8], is_bos: bool, is_eos: bool, is_continuation: bool) -> Vec<u8> {
+        use std::io::Write;
+
+        let mut segments = Vec::new();
+        let mut remaining = packet_data.len();
+        while remaining > 0 {
+            let seg = remaining.min(255);
+            segments.push(seg as u8);
+            remaining -= seg;
+        }
+        if !packet_data.is_empty() && packet_data.len() % 255 == 0 && !is_continuation {
+            segments.push(0);
+        }
+
+        let segment_count = segments.len();
+        let total_size = 27 + segment_count + packet_data.len();
+        let mut page = Vec::with_capacity(total_size);
+
+        page.write_all(b"OggS").unwrap();
+        page.write_all(&[0]).unwrap();
+
+        let mut header_type = 0u8;
+        if is_continuation { header_type |= 0x01; }
+        if is_bos         { header_type |= 0x02; }
+        if is_eos         { header_type |= 0x04; }
+        page.write_all(&[header_type]).unwrap();
+
+        page.write_all(&self.granule_position.to_le_bytes()).unwrap();
+        page.write_all(&self.stream_serial.to_le_bytes()).unwrap();
+        page.write_all(&self.page_sequence.to_le_bytes()).unwrap();
+        self.page_sequence += 1;
+
+        let crc_offset = page.len();
+        page.write_all(&[0, 0, 0, 0]).unwrap();
+        page.write_all(&[segment_count as u8]).unwrap();
+        page.write_all(&segments).unwrap();
+        page.write_all(packet_data).unwrap();
+
+        let crc = calculate_ogg_crc(&page);
+        page[crc_offset..crc_offset + 4].copy_from_slice(&crc.to_le_bytes());
+
+        page
+    }
+}
+
+fn calculate_ogg_crc(data: &[u8]) -> u32 {
+    const CRC_TABLE: [u32; 256] = generate_crc_table();
+    let mut crc: u32 = 0;
+    for &byte in data {
+        crc = (crc << 8) ^ CRC_TABLE[((crc >> 24) ^ (byte as u32)) as usize];
+    }
+    crc
+}
+
+const fn generate_crc_table() -> [u32; 256] {
+    let mut table = [0u32; 256];
+    let mut i = 0usize;
+    while i < 256 {
+        let mut r = (i as u32) << 24;
+        let mut j = 0;
+        while j < 8 {
+            if (r & 0x80000000) != 0 { r = (r << 1) ^ 0x04c11db7; } else { r <<= 1; }
+            j += 1;
+        }
+        table[i] = r;
+        i += 1;
+    }
+    table
+}
+
+fn create_ogg_flac_identification(flac_header: &[u8]) -> Result<Vec<u8>, AudioError> {
+    if flac_header.len() < 8 || &flac_header[0..4] != b"fLaC" {
+        return Err(AudioError::ProcessingError("Invalid FLAC header".into()));
+    }
+    let first_block_type = flac_header[4] & 0x7F;
+    if first_block_type != 0 {
+        return Err(AudioError::ProcessingError("First FLAC block is not STREAMINFO".into()));
+    }
+    let block_length = u32::from_be_bytes([0, flac_header[5], flac_header[6], flac_header[7]]) as usize;
+    let streaminfo_size = 4 + block_length;
+    if flac_header.len() < 4 + streaminfo_size {
+        return Err(AudioError::ProcessingError("FLAC header truncated".into()));
+    }
+    let streaminfo = &flac_header[4..4 + streaminfo_size];
+
+    let mut packet = Vec::new();
+    packet.push(0x7F);
+    packet.extend_from_slice(b"FLAC");
+    packet.push(0x01);
+    packet.push(0x00);
+    packet.extend_from_slice(&1u16.to_be_bytes());
+    packet.extend_from_slice(b"fLaC");
+    packet.extend_from_slice(streaminfo);
+    Ok(packet)
+}
+
+fn create_empty_vorbis_comment() -> Vec<u8> {
+    let vendor = "pmoaudio DirectOggFlacSink";
+    let vendor_bytes = vendor.as_bytes();
+    let mut vorbis_data = Vec::new();
+    vorbis_data.extend_from_slice(&(vendor_bytes.len() as u32).to_le_bytes());
+    vorbis_data.extend_from_slice(vendor_bytes);
+    vorbis_data.extend_from_slice(&0u32.to_le_bytes());
+
+    let mut block = Vec::new();
+    block.push(0x84); // last-block + VORBIS_COMMENT type
+    let length = vorbis_data.len() as u32;
+    block.push((length >> 16) as u8);
+    block.push((length >> 8) as u8);
+    block.push(length as u8);
+    block.extend_from_slice(&vorbis_data);
+    block
+}
+
+// ─── Nœud public ─────────────────────────────────────────────────────────────
+
+pub struct DirectOggFlacSink {
+    inner: Node<DirectOggFlacSinkLogic>,
+}
+
+impl DirectOggFlacSink {
+    pub fn new(encoder_options: EncoderOptions) -> (Self, DirectOggFlacHandle) {
+        let pcm_tx: SharedPcmTx = Arc::new(Mutex::new(None));
+        let client_notify_internal = Arc::new(tokio::sync::Notify::new());
+        let (client_connect_tx, _) = watch::channel(0u64);
+        let client_connect_tx = Arc::new(client_connect_tx);
+        let (first_byte_tx, _) = watch::channel(false);
+        let first_byte_tx = Arc::new(first_byte_tx);
+        let current_timestamp = Arc::new(tokio::sync::RwLock::new(0.0f64));
+
+        let logic = DirectOggFlacSinkLogic {
+            pcm_tx: pcm_tx.clone(),
+            client_notify: client_notify_internal.clone(),
+        };
+
+        let sink = Self {
+            inner: Node::new_with_input(logic, 16),
+        };
+
+        let handle = DirectOggFlacHandle {
+            pcm_tx,
+            client_connect_tx,
+            client_notify_internal,
+            first_byte_tx,
+            encoder_options,
+            current_timestamp,
+        };
+
+        (sink, handle)
+    }
+}
+
+#[async_trait]
+impl AudioPipelineNode for DirectOggFlacSink {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> {
+        self.inner.get_tx()
+    }
+
+    fn register(&mut self, _child: Box<dyn AudioPipelineNode>) {
+        panic!("DirectOggFlacSink is a terminal sink and cannot have children");
+    }
+
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.inner).run(stop_token).await
+    }
+
+    fn start(self: Box<Self>) -> PipelineHandle {
+        Box::new(self.inner).start()
+    }
+}
+
+impl TypedAudioNode for DirectOggFlacSink {
+    fn input_type(&self) -> Option<TypeRequirement> {
+        Some(TypeRequirement::any_integer())
+    }
+
+    fn output_type(&self) -> Option<TypeRequirement> {
+        None
+    }
+}
diff --git a/pmoaudio-ext/src/sinks/mod.rs b/pmoaudio-ext/src/sinks/mod.rs
index 0aa776ca..fd0eb3f1 100755
--- a/pmoaudio-ext/src/sinks/mod.rs
+++ b/pmoaudio-ext/src/sinks/mod.rs
@@ -23,6 +23,24 @@ mod flac_frame_utils;
 #[cfg(feature = "http-stream")]
 mod timed_broadcast;
 
+#[cfg(feature = "http-stream")]
+mod direct_flac_sink;
+
+#[cfg(feature = "http-stream")]
+pub use direct_flac_sink::{
+    DirectFlacHandle, DirectFlacSink, DirectFlacStream,
+    DIRECT_FLAC_BITS_PER_SAMPLE, DIRECT_FLAC_CHANNELS, DIRECT_FLAC_SAMPLE_RATE,
+};
+
+#[cfg(feature = "http-stream")]
+mod direct_ogg_flac_sink;
+
+#[cfg(feature = "http-stream")]
+pub use direct_ogg_flac_sink::{
+    DirectOggFlacHandle, DirectOggFlacSink, DirectOggFlacStream,
+    DIRECT_OGG_FLAC_BITS_PER_SAMPLE, DIRECT_OGG_FLAC_CHANNELS, DIRECT_OGG_FLAC_SAMPLE_RATE,
+};
+
 #[cfg(feature = "http-stream")]
 mod streaming_flac_sink;
 
diff --git a/pmoaudio-ext/src/sinks/streaming_sink_common.rs b/pmoaudio-ext/src/sinks/streaming_sink_common.rs
index 43b47ddb..e2e9142f 100644
--- a/pmoaudio-ext/src/sinks/streaming_sink_common.rs
+++ b/pmoaudio-ext/src/sinks/streaming_sink_common.rs
@@ -215,7 +215,13 @@ impl AsyncRead for SharedClientStream {
                     self.state = StreamState::Streaming;
                     continue;
                 } else {
-                    self.state = StreamState::Streaming;
+                    // Header not yet available (encoder not yet started): wait and retry
+                    let waker = cx.waker().clone();
+                    tokio::spawn(async move {
+                        tokio::time::sleep(Duration::from_millis(10)).await;
+                        waker.wake();
+                    });
+                    return Poll::Pending;
                 }
             }
 
diff --git a/pmoaudio-ext/src/sources/mod.rs b/pmoaudio-ext/src/sources/mod.rs
index a3d2aa46..ce87b685 100644
--- a/pmoaudio-ext/src/sources/mod.rs
+++ b/pmoaudio-ext/src/sources/mod.rs
@@ -3,8 +3,19 @@
 //! Ce module contient des sources audio qui dépendent d'autres crates
 //! du projet PMO (pmoplaylist, pmoaudiocache, etc.)
 
+// Helpers partagés (conversion PCM → AudioSegment)
+// Disponibles dès que l'une des deux features qui en dépend est activée
+#[cfg(any(feature = "playlist", feature = "http-stream"))]
+pub(crate) mod pcm_decode;
+
 #[cfg(feature = "playlist")]
 mod playlist_source;
 
 #[cfg(feature = "playlist")]
 pub use playlist_source::PlaylistSource;
+
+#[cfg(feature = "http-stream")]
+mod uri_source;
+
+#[cfg(feature = "http-stream")]
+pub use uri_source::UriSource;
diff --git a/pmoaudio-ext/src/sources/pcm_decode.rs b/pmoaudio-ext/src/sources/pcm_decode.rs
new file mode 100644
index 00000000..9eeee193
--- /dev/null
+++ b/pmoaudio-ext/src/sources/pcm_decode.rs
@@ -0,0 +1,145 @@
+//! Helpers partagés pour le décodage PCM → AudioSegment
+//!
+//! Utilisés par `PlaylistSource` et `UriSource`.
+//!
+//! Les fonctions `bytes_to_segment` et `validate_stream` ont été extraites
+//! de `playlist_source.rs` sans modification pour éviter toute duplication.
+
+use std::sync::Arc;
+
+use pmoaudio::{AudioChunk, AudioChunkData, AudioSegment, I24, _AudioSegment, nodes::AudioError};
+use pmoflac::StreamInfo;
+
+pub(crate) fn validate_stream(info: &StreamInfo) -> Result<(), AudioError> {
+    if !(1..=2).contains(&info.channels) {
+        return Err(AudioError::ProcessingError(format!(
+            "Unsupported channel count: {}",
+            info.channels
+        )));
+    }
+    match info.bits_per_sample {
+        8 | 16 | 24 | 32 => Ok(()),
+        other => Err(AudioError::ProcessingError(format!(
+            "Unsupported bit depth: {}",
+            other
+        ))),
+    }
+}
+
+/// Convertit des bytes PCM en AudioSegment avec le type approprié
+pub(crate) fn bytes_to_segment(
+    chunk_bytes: &[u8],
+    info: &StreamInfo,
+    frames: usize,
+    order: u64,
+    timestamp_sec: f64,
+) -> Result<Arc<AudioSegment>, AudioError> {
+    let bytes_per_sample = info.bytes_per_sample();
+    let channels = info.channels as usize;
+    let frame_bytes = bytes_per_sample * channels;
+
+    // Créer le chunk du bon type selon la profondeur de bit
+    let chunk = match info.bits_per_sample {
+        16 => {
+            // Type I16
+            let mut stereo = Vec::with_capacity(frames);
+            for frame_idx in 0..frames {
+                let base = frame_idx * frame_bytes;
+                let l = i16::from_le_bytes(
+                    chunk_bytes[base..base + bytes_per_sample]
+                        .try_into()
+                        .unwrap(),
+                );
+                let r = if channels == 1 {
+                    l
+                } else {
+                    i16::from_le_bytes(
+                        chunk_bytes[base + bytes_per_sample..base + 2 * bytes_per_sample]
+                            .try_into()
+                            .unwrap(),
+                    )
+                };
+                stereo.push([l, r]);
+            }
+            let chunk_data = AudioChunkData::new(stereo, info.sample_rate, 0.0);
+            AudioChunk::I16(chunk_data)
+        }
+        24 => {
+            // Type I24
+            let mut stereo = Vec::with_capacity(frames);
+            for frame_idx in 0..frames {
+                let base = frame_idx * frame_bytes;
+                let l_i32 = {
+                    let mut buf = [0u8; 4];
+                    buf[..3].copy_from_slice(&chunk_bytes[base..base + 3]);
+                    // Sign extend
+                    if chunk_bytes[base + 2] & 0x80 != 0 {
+                        buf[3] = 0xFF;
+                    }
+                    i32::from_le_bytes(buf)
+                };
+                let l = I24::new(l_i32).ok_or_else(|| {
+                    AudioError::ProcessingError(format!("Invalid I24 value: {}", l_i32))
+                })?;
+
+                let r = if channels == 1 {
+                    l
+                } else {
+                    let r_i32 = {
+                        let mut buf = [0u8; 4];
+                        buf[..3].copy_from_slice(
+                            &chunk_bytes[base + bytes_per_sample..base + bytes_per_sample + 3],
+                        );
+                        // Sign extend
+                        if chunk_bytes[base + bytes_per_sample + 2] & 0x80 != 0 {
+                            buf[3] = 0xFF;
+                        }
+                        i32::from_le_bytes(buf)
+                    };
+                    I24::new(r_i32).ok_or_else(|| {
+                        AudioError::ProcessingError(format!("Invalid I24 value: {}", r_i32))
+                    })?
+                };
+                stereo.push([l, r]);
+            }
+            let chunk_data = AudioChunkData::new(stereo, info.sample_rate, 0.0);
+            AudioChunk::I24(chunk_data)
+        }
+        32 => {
+            // Type I32
+            let mut stereo = Vec::with_capacity(frames);
+            for frame_idx in 0..frames {
+                let base = frame_idx * frame_bytes;
+                let l = i32::from_le_bytes(
+                    chunk_bytes[base..base + bytes_per_sample]
+                        .try_into()
+                        .unwrap(),
+                );
+                let r = if channels == 1 {
+                    l
+                } else {
+                    i32::from_le_bytes(
+                        chunk_bytes[base + bytes_per_sample..base + 2 * bytes_per_sample]
+                            .try_into()
+                            .unwrap(),
+                    )
+                };
+                stereo.push([l, r]);
+            }
+            let chunk_data = AudioChunkData::new(stereo, info.sample_rate, 0.0);
+            AudioChunk::I32(chunk_data)
+        }
+        _ => {
+            return Err(AudioError::ProcessingError(format!(
+                "Unsupported bit depth: {}",
+                info.bits_per_sample
+            )))
+        }
+    };
+
+    Ok(Arc::new(AudioSegment {
+        order,
+        timestamp_sec,
+        segment: _AudioSegment::Chunk(Arc::new(chunk)),
+    }))
+}
diff --git a/pmoaudio-ext/src/sources/playlist_source.rs b/pmoaudio-ext/src/sources/playlist_source.rs
index 34ca7322..845b8541 100644
--- a/pmoaudio-ext/src/sources/playlist_source.rs
+++ b/pmoaudio-ext/src/sources/playlist_source.rs
@@ -113,11 +113,13 @@ use pmoaudio::{
     nodes::{AudioError, TypedAudioNode, DEFAULT_CHUNK_DURATION_MS},
     pipeline::{send_to_children, AudioPipelineNode, Node, NodeLogic},
     type_constraints::TypeRequirement,
-    AudioChunk, AudioChunkData, AudioSegment, I24,
+    AudioSegment,
 };
 use pmoaudiocache::Cache as AudioCache;
 use pmoflac::{decode_audio_stream, StreamInfo};
 use pmoplaylist::{PlaylistRole, ReadHandle};
+
+use super::pcm_decode::{bytes_to_segment, validate_stream};
 use std::{path::PathBuf, sync::Arc, time::Duration};
 use tokio::{fs::File, io::AsyncReadExt, sync::mpsc};
 use tokio_util::sync::CancellationToken;
@@ -563,139 +565,6 @@ async fn decode_and_emit_track(
     Ok(())
 }
 
-fn validate_stream(info: &StreamInfo) -> Result<(), AudioError> {
-    if !(1..=2).contains(&info.channels) {
-        return Err(AudioError::ProcessingError(format!(
-            "Unsupported channel count: {}",
-            info.channels
-        )));
-    }
-    match info.bits_per_sample {
-        8 | 16 | 24 | 32 => Ok(()),
-        other => Err(AudioError::ProcessingError(format!(
-            "Unsupported bit depth: {}",
-            other
-        ))),
-    }
-}
-
-/// Convertit des bytes PCM en AudioSegment avec le type approprié
-fn bytes_to_segment(
-    chunk_bytes: &[u8],
-    info: &StreamInfo,
-    frames: usize,
-    order: u64,
-    timestamp_sec: f64,
-) -> Result<Arc<AudioSegment>, AudioError> {
-    let bytes_per_sample = info.bytes_per_sample();
-    let channels = info.channels as usize;
-    let frame_bytes = bytes_per_sample * channels;
-
-    // Créer le chunk du bon type selon la profondeur de bit
-    let chunk = match info.bits_per_sample {
-        16 => {
-            // Type I16
-            let mut stereo = Vec::with_capacity(frames);
-            for frame_idx in 0..frames {
-                let base = frame_idx * frame_bytes;
-                let l = i16::from_le_bytes(
-                    chunk_bytes[base..base + bytes_per_sample]
-                        .try_into()
-                        .unwrap(),
-                );
-                let r = if channels == 1 {
-                    l
-                } else {
-                    i16::from_le_bytes(
-                        chunk_bytes[base + bytes_per_sample..base + 2 * bytes_per_sample]
-                            .try_into()
-                            .unwrap(),
-                    )
-                };
-                stereo.push([l, r]);
-            }
-            let chunk_data = AudioChunkData::new(stereo, info.sample_rate, 0.0);
-            AudioChunk::I16(chunk_data)
-        }
-        24 => {
-            // Type I24
-            let mut stereo = Vec::with_capacity(frames);
-            for frame_idx in 0..frames {
-                let base = frame_idx * frame_bytes;
-                let l_i32 = {
-                    let mut buf = [0u8; 4];
-                    buf[..3].copy_from_slice(&chunk_bytes[base..base + 3]);
-                    // Sign extend
-                    if chunk_bytes[base + 2] & 0x80 != 0 {
-                        buf[3] = 0xFF;
-                    }
-                    i32::from_le_bytes(buf)
-                };
-                let l = I24::new(l_i32).ok_or_else(|| {
-                    AudioError::ProcessingError(format!("Invalid I24 value: {}", l_i32))
-                })?;
-
-                let r = if channels == 1 {
-                    l
-                } else {
-                    let r_i32 = {
-                        let mut buf = [0u8; 4];
-                        buf[..3].copy_from_slice(
-                            &chunk_bytes[base + bytes_per_sample..base + bytes_per_sample + 3],
-                        );
-                        // Sign extend
-                        if chunk_bytes[base + bytes_per_sample + 2] & 0x80 != 0 {
-                            buf[3] = 0xFF;
-                        }
-                        i32::from_le_bytes(buf)
-                    };
-                    I24::new(r_i32).ok_or_else(|| {
-                        AudioError::ProcessingError(format!("Invalid I24 value: {}", r_i32))
-                    })?
-                };
-                stereo.push([l, r]);
-            }
-            let chunk_data = AudioChunkData::new(stereo, info.sample_rate, 0.0);
-            AudioChunk::I24(chunk_data)
-        }
-        32 => {
-            // Type I32
-            let mut stereo = Vec::with_capacity(frames);
-            for frame_idx in 0..frames {
-                let base = frame_idx * frame_bytes;
-                let l = i32::from_le_bytes(
-                    chunk_bytes[base..base + bytes_per_sample]
-                        .try_into()
-                        .unwrap(),
-                );
-                let r = if channels == 1 {
-                    l
-                } else {
-                    i32::from_le_bytes(
-                        chunk_bytes[base + bytes_per_sample..base + 2 * bytes_per_sample]
-                            .try_into()
-                            .unwrap(),
-                    )
-                };
-                stereo.push([l, r]);
-            }
-            let chunk_data = AudioChunkData::new(stereo, info.sample_rate, 0.0);
-            AudioChunk::I32(chunk_data)
-        }
-        _ => {
-            return Err(AudioError::ProcessingError(format!(
-                "Unsupported bit depth: {}",
-                info.bits_per_sample
-            )))
-        }
-    };
-
-    Ok(Arc::new(AudioSegment {
-        order,
-        timestamp_sec,
-        segment: pmoaudio::_AudioSegment::Chunk(Arc::new(chunk)),
-    }))
-}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // WRAPPER PlaylistSource - Délègue à Node<PlaylistSourceLogic>
@@ -795,6 +664,7 @@ impl TypedAudioNode for PlaylistSource {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use pmoaudio::AudioChunk;
 
     // ═══════════════════════════════════════════════════════════════════════════
     // Tests unitaires pour les fonctions helper
diff --git a/pmoaudio-ext/src/sources/uri_source.rs b/pmoaudio-ext/src/sources/uri_source.rs
new file mode 100644
index 00000000..ecf7c196
--- /dev/null
+++ b/pmoaudio-ext/src/sources/uri_source.rs
@@ -0,0 +1,254 @@
+//! UriSource - Source audio depuis une URI arbitraire
+//!
+//! Ouvre une URI (fichier local ou HTTP/HTTPS), décode l'audio (tout format
+//! supporté par `pmoflac` : FLAC, MP3, OGG, WAV, AIFF) et émet des `AudioSegment`
+//! vers un sender tokio.
+//!
+//! # Usage
+//!
+//! ```rust,no_run
+//! use pmoaudio_ext::sources::UriSource;
+//! use tokio_util::sync::CancellationToken;
+//! use tokio::sync::mpsc;
+//! use std::sync::Arc;
+//! use pmoaudio::AudioSegment;
+//!
+//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+//! let (tx, mut rx) = mpsc::channel::<Arc<AudioSegment>>(64);
+//! let stop = CancellationToken::new();
+//!
+//! let source = UriSource::open("/music/track.flac", 0.0, stop.clone()).await?;
+//! println!("Duration: {:?}", source.duration_sec());
+//!
+//! let eof = source.emit_to_channel(&tx, &stop).await?;
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Seek
+//!
+//! Implémenté par skip des frames initiales. Pour les formats sans seek natif
+//! (MP3, stream HTTP), tout le contenu est lu mais les frames avant `seek_sec`
+//! ne sont pas émises.
+
+use std::sync::Arc;
+
+use pmoaudio::{AudioSegment, nodes::AudioError};
+use pmoflac::{StreamInfo, decode_audio_stream};
+use tokio::io::AsyncReadExt;
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+use tracing::{debug, info};
+
+use super::pcm_decode::{bytes_to_segment, validate_stream};
+
+const CHUNK_FRAMES: usize = 2048; // ~46ms @ 44.1kHz
+
+/// Source audio ouverte depuis une URI, prête à émettre des segments.
+pub struct UriSource {
+    reader: Box<dyn tokio::io::AsyncRead + Send + Unpin>,
+    stream_info: StreamInfo,
+    frames_to_skip: u64,
+}
+
+impl UriSource {
+    /// Ouvre une URI et prépare la source.
+    ///
+    /// - Chemin absolu ou `file://...` → fichier local
+    /// - `http://...` / `https://...` → streaming HTTP
+    pub async fn open(
+        uri: &str,
+        seek_sec: f64,
+        stop_token: CancellationToken,
+    ) -> Result<Self, AudioError> {
+        if uri.starts_with("http://") || uri.starts_with("https://") {
+            Self::open_http(uri, seek_sec, &stop_token).await
+        } else {
+            let path = uri.strip_prefix("file://").unwrap_or(uri);
+            Self::open_file(path, seek_sec).await
+        }
+    }
+
+    /// Durée totale en secondes, si connue.
+    pub fn duration_sec(&self) -> Option<f64> {
+        let info = &self.stream_info;
+        info.total_samples
+            .filter(|&s| s > 0)
+            .map(|s| s as f64 / info.sample_rate as f64)
+    }
+
+    /// Nombre total de samples à 96 kHz après resampling, si connu.
+    /// Utilisé pour renseigner STREAMINFO.total_samples dans le FLAC de sortie.
+    pub fn total_samples_at(&self, output_sample_rate: u32) -> Option<u64> {
+        let info = &self.stream_info;
+        info.total_samples.filter(|&s| s > 0).map(|s| {
+            // Convertir le nombre de samples source vers le sample rate de sortie
+            let ratio = output_sample_rate as f64 / info.sample_rate as f64;
+            (s as f64 * ratio).round() as u64
+        })
+    }
+
+    /// Émet les chunks audio vers `tx`.
+    ///
+    /// Retourne `Ok(true)` si EOF naturel, `Ok(false)` si annulé ou receiver fermé.
+    pub async fn emit_to_channel(
+        mut self,
+        tx: &mpsc::Sender<Arc<AudioSegment>>,
+        stop_token: &CancellationToken,
+    ) -> Result<bool, AudioError> {
+        let info = self.stream_info.clone();
+        let bytes_per_sample = info.bytes_per_sample();
+        let frame_bytes = bytes_per_sample * info.channels as usize;
+        let chunk_byte_len = CHUNK_FRAMES * frame_bytes;
+
+        let mut pending = Vec::new();
+        let mut read_buf = vec![0u8; frame_bytes * 512.max(CHUNK_FRAMES)];
+        let mut chunk_index = 0u64;
+        let mut total_frames = 0u64;
+
+        loop {
+            tokio::select! {
+                _ = stop_token.cancelled() => {
+                    debug!("UriSource: cancelled");
+                    return Ok(false);
+                }
+
+                read_result = self.reader.read(&mut read_buf) => {
+                    let read = read_result
+                        .map_err(|e| AudioError::IoError(e.to_string()))?;
+
+                    if read == 0 {
+                        break; // EOF
+                    }
+
+                    pending.extend_from_slice(&read_buf[..read]);
+
+                    while pending.len() >= chunk_byte_len {
+                        let chunk_bytes = pending.drain(..chunk_byte_len).collect::<Vec<_>>();
+                        let frames = CHUNK_FRAMES;
+
+                        // Seek : ignorer les frames avant la position demandée
+                        if total_frames + frames as u64 <= self.frames_to_skip {
+                            total_frames += frames as u64;
+                            chunk_index += 1;
+                            continue;
+                        }
+
+                        let timestamp_sec = total_frames as f64 / info.sample_rate as f64;
+                        let segment = bytes_to_segment(&chunk_bytes, &info, frames, chunk_index, timestamp_sec)?;
+
+                        if tx.send(segment).await.is_err() {
+                            debug!("UriSource: receiver dropped");
+                            return Ok(false);
+                        }
+
+                        total_frames += frames as u64;
+                        chunk_index += 1;
+                    }
+                }
+            }
+        }
+
+        // Émettre le reste (< un chunk complet)
+        if !pending.is_empty() {
+            let frames = pending.len() / frame_bytes;
+            if frames > 0 && total_frames >= self.frames_to_skip {
+                let timestamp_sec = total_frames as f64 / info.sample_rate as f64;
+                if let Ok(seg) = bytes_to_segment(
+                    &pending[..frames * frame_bytes],
+                    &info,
+                    frames,
+                    chunk_index,
+                    timestamp_sec,
+                ) {
+                    let _ = tx.send(seg).await;
+                }
+            }
+        }
+
+        info!(
+            "UriSource: EOF after {} frames ({:.1}s)",
+            total_frames,
+            total_frames as f64 / info.sample_rate.max(1) as f64
+        );
+        Ok(true)
+    }
+
+    // ── Constructeurs internes ────────────────────────────────────────────────
+
+    async fn open_file(path: &str, seek_sec: f64) -> Result<Self, AudioError> {
+        let file = tokio::fs::File::open(path)
+            .await
+            .map_err(|e| AudioError::IoError(format!("Cannot open {:?}: {}", path, e)))?;
+
+        let stream = decode_audio_stream(file)
+            .await
+            .map_err(|e| AudioError::ProcessingError(format!("Decode error: {}", e)))?;
+
+        let stream_info = stream.info().clone();
+        validate_stream(&stream_info)?;
+
+        let frames_to_skip = (seek_sec * stream_info.sample_rate as f64) as u64;
+
+        info!(
+            "UriSource: opened file {} Hz {} ch {} bps {:.1}s",
+            stream_info.sample_rate,
+            stream_info.channels,
+            stream_info.bits_per_sample,
+            stream_info.total_samples
+                .map(|s| s as f64 / stream_info.sample_rate as f64)
+                .unwrap_or(0.0),
+        );
+
+        let (_, reader) = stream.into_reader();
+        Ok(Self { reader: Box::new(reader), stream_info, frames_to_skip })
+    }
+
+    async fn open_http(
+        url: &str,
+        seek_sec: f64,
+        stop_token: &CancellationToken,
+    ) -> Result<Self, AudioError> {
+        let response = tokio::select! {
+            _ = stop_token.cancelled() => {
+                return Err(AudioError::IoError("Cancelled before HTTP connect".into()));
+            }
+            result = reqwest::get(url) => {
+                result.map_err(|e| AudioError::IoError(format!("HTTP error: {}", e)))?
+            }
+        };
+
+        if !response.status().is_success() {
+            return Err(AudioError::IoError(format!(
+                "HTTP {} for {}",
+                response.status(),
+                url
+            )));
+        }
+
+        use futures::TryStreamExt;
+        use tokio_util::io::StreamReader;
+
+        let byte_stream = response
+            .bytes_stream()
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e));
+        let reader = StreamReader::new(byte_stream);
+
+        let stream = decode_audio_stream(reader)
+            .await
+            .map_err(|e| AudioError::ProcessingError(format!("Decode error: {}", e)))?;
+
+        let stream_info = stream.info().clone();
+        validate_stream(&stream_info)?;
+
+        let frames_to_skip = (seek_sec * stream_info.sample_rate as f64) as u64;
+
+        info!(
+            "UriSource: opened HTTP {} Hz {} ch {} bps",
+            stream_info.sample_rate, stream_info.channels, stream_info.bits_per_sample,
+        );
+
+        let (_, reader) = stream.into_reader();
+        Ok(Self { reader: Box::new(reader), stream_info, frames_to_skip })
+    }
+}
diff --git a/pmoaudio/examples/convert_to_flac24.rs b/pmoaudio/examples/convert_to_flac24.rs
index b27b7bb0..acb174cc 100755
--- a/pmoaudio/examples/convert_to_flac24.rs
+++ b/pmoaudio/examples/convert_to_flac24.rs
@@ -70,8 +70,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let sink = FlacFileSink::new(output_path);
 
     // Construire la chaîne: source → converter → sink
-    converter.register(Box::new(sink));
-    source.register(converter);
+    converter.register(sink.boxed());
+    source.register(converter.boxed());
 
     // Créer un token d'arrêt pour contrôle manuel si besoin
     let stop_token = CancellationToken::new();
diff --git a/pmoaudio/examples/file_nodes_test.rs b/pmoaudio/examples/file_nodes_test.rs
index e40f1d5e..758d2b6b 100755
--- a/pmoaudio/examples/file_nodes_test.rs
+++ b/pmoaudio/examples/file_nodes_test.rs
@@ -38,7 +38,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let sink = FlacFileSink::new(output_path);
 
     // Enregistrer le sink comme enfant de la source
-    source.register(Box::new(sink));
+    source.register(sink.boxed());
 
     // Créer un token d'arrêt pour contrôle manuel si besoin
     let stop_token = CancellationToken::new();
diff --git a/pmoaudio/examples/play_audio.rs b/pmoaudio/examples/play_audio.rs
index 07f2bfbf..c3ed80e0 100644
--- a/pmoaudio/examples/play_audio.rs
+++ b/pmoaudio/examples/play_audio.rs
@@ -34,7 +34,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let sink = AudioSink::new();
 
     // Connecter la source au sink
-    source.register(Box::new(sink));
+    source.register(sink.boxed());
 
     println!("Démarrage de la lecture...");
     println!("Appuyez sur Ctrl+C pour arrêter");
diff --git a/pmoaudio/examples/play_with_resampling.rs b/pmoaudio/examples/play_with_resampling.rs
index 2b856672..3bac8c0b 100644
--- a/pmoaudio/examples/play_with_resampling.rs
+++ b/pmoaudio/examples/play_with_resampling.rs
@@ -35,22 +35,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Lecture de: {}", file_path);
     println!("Sample rate cible: {} Hz", target_sample_rate);
 
-    // Créer la source audio
-    let mut source = FileSource::new(file_path).await?;
-
-    // Créer le nœud de resampling
-    let mut resampler = ResamplingNode::new(target_sample_rate);
-
-    // Créer le nœud de conversion vers I24
-    let mut converter = ToI24Node::new();
-
-    // Créer le sink audio avec volume à 80%
-    let sink = AudioSink::with_volume(0.8);
-
     // Construire le pipeline: Source → Resampler → Converter → Sink
-    source.register(Box::new(resampler));
-    resampler.register(Box::new(converter));
-    converter.register(Box::new(sink));
+    let sink = AudioSink::new();
+    let mut converter = ToI24Node::new();
+    converter.register(sink.boxed());
+
+    let mut resampler = ResamplingNode::new(target_sample_rate);
+    resampler.register(converter.boxed());
+
+    let mut source = FileSource::new(file_path);
+    source.register(resampler.boxed());
 
     println!(
         "Pipeline créé: FileSource → Resampling({} Hz) → ToI24 → AudioSink",
diff --git a/pmoaudio/src/lib.rs b/pmoaudio/src/lib.rs
index 838d94a4..43b9568c 100755
--- a/pmoaudio/src/lib.rs
+++ b/pmoaudio/src/lib.rs
@@ -126,6 +126,7 @@ pub use nodes::{
     resampling_node::ResamplingNode,
     timer_buffer_node::TimerBufferNode,
     timer_node::TimerNode,
+    position_tracker_node::{PositionHandle, PositionTrackerNode},
     AudioError, AudioNode, TypedAudioNode,
 };
 
diff --git a/pmoaudio/src/nodes/audio_sink.rs b/pmoaudio/src/nodes/audio_sink.rs
index 4ba91f19..f995800d 100644
--- a/pmoaudio/src/nodes/audio_sink.rs
+++ b/pmoaudio/src/nodes/audio_sink.rs
@@ -547,19 +547,23 @@ impl AudioSink {
         }
     }
 
+    pub fn make() -> Box<dyn AudioPipelineNode> {
+        Self::new().boxed()
+    }
+
     /// Crée un nouveau AudioSink avec une taille de channel personnalisée
-    pub fn with_channel_size(channel_size: usize) -> Self {
+    pub fn with_channel_size(channel_size: usize) -> Box<dyn AudioPipelineNode> {
         Self {
             inner: Node::new_with_input(AudioSinkLogic::new(), channel_size),
-        }
+        }.boxed()
     }
 
     /// Crée un AudioSink avec null output (pour tests sans carte audio)
     /// Consomme les segments audio sans les jouer
-    pub fn with_null_output() -> Self {
+    pub fn with_null_output() -> Box<dyn AudioPipelineNode> {
         Self {
             inner: Node::new_with_input(AudioSinkLogic::with_null_output(), DEFAULT_CHANNEL_SIZE),
-        }
+        }.boxed()
     }
 }
 
diff --git a/pmoaudio/src/nodes/converter_nodes.rs b/pmoaudio/src/nodes/converter_nodes.rs
index 952cf3ae..925ef3c0 100755
--- a/pmoaudio/src/nodes/converter_nodes.rs
+++ b/pmoaudio/src/nodes/converter_nodes.rs
@@ -22,6 +22,7 @@ use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
 
+
 /// Logique de conversion générique
 ///
 /// Cette struct contient la logique pure de conversion d'un type vers un autre.
@@ -112,102 +113,162 @@ where
 // ═══════════════════════════════════════════════════════════════════════════
 
 /// Node de conversion vers I16 (16-bit signed integer)
-pub struct ToI16Node;
+pub struct ToI16Node(Node<ConverterLogic<fn(&AudioChunk) -> AudioChunk>>);
 
 impl ToI16Node {
-    pub fn new() -> Box<dyn AudioPipelineNode> {
-        Self::with_channel_size(16)
+    pub fn new() -> Self {
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i16()), 16))
+    }
+
+    pub fn make() -> Box<dyn AudioPipelineNode> {
+        Self::new().boxed()
     }
 
     pub fn with_channel_size(channel_size: usize) -> Box<dyn AudioPipelineNode> {
-        let logic = ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i16());
-        Box::new(Node::new_with_input(logic, channel_size))
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i16()), channel_size)).boxed()
     }
 }
 
 impl Default for ToI16Node {
     fn default() -> Self {
-        Self
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl AudioPipelineNode for ToI16Node {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> { self.0.get_tx() }
+    fn register(&mut self, child: Box<dyn AudioPipelineNode>) { self.0.register(child) }
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.0).run(stop_token).await
     }
 }
 
 /// Node de conversion vers I24 (24-bit signed integer)
-pub struct ToI24Node;
+pub struct ToI24Node(Node<ConverterLogic<fn(&AudioChunk) -> AudioChunk>>);
 
 impl ToI24Node {
-    pub fn new() -> Box<dyn AudioPipelineNode> {
-        Self::with_channel_size(16)
+    pub fn new() -> Self {
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i24()), 16))
+    }
+
+    pub fn make() -> Box<dyn AudioPipelineNode> {
+        Self::new().boxed()
     }
 
     pub fn with_channel_size(channel_size: usize) -> Box<dyn AudioPipelineNode> {
-        let logic = ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i24());
-        Box::new(Node::new_with_input(logic, channel_size))
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i24()), channel_size)).boxed()
     }
 }
 
 impl Default for ToI24Node {
     fn default() -> Self {
-        Self
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl AudioPipelineNode for ToI24Node {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> { self.0.get_tx() }
+    fn register(&mut self, child: Box<dyn AudioPipelineNode>) { self.0.register(child) }
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.0).run(stop_token).await
     }
 }
 
 /// Node de conversion vers I32 (32-bit signed integer)
-pub struct ToI32Node;
+pub struct ToI32Node(Node<ConverterLogic<fn(&AudioChunk) -> AudioChunk>>);
 
 impl ToI32Node {
-    pub fn new() -> Box<dyn AudioPipelineNode> {
-        Self::with_channel_size(16)
+    pub fn new() -> Self {
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i32()), 16))
+    }
+
+    pub fn make() -> Box<dyn AudioPipelineNode> {
+        Self::new().boxed()
     }
 
     pub fn with_channel_size(channel_size: usize) -> Box<dyn AudioPipelineNode> {
-        let logic = ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i32());
-        Box::new(Node::new_with_input(logic, channel_size))
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_i32()), channel_size)).boxed()
     }
 }
 
 impl Default for ToI32Node {
     fn default() -> Self {
-        Self
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl AudioPipelineNode for ToI32Node {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> { self.0.get_tx() }
+    fn register(&mut self, child: Box<dyn AudioPipelineNode>) { self.0.register(child) }
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.0).run(stop_token).await
     }
 }
 
 /// Node de conversion vers F32 (32-bit floating point)
-pub struct ToF32Node;
+pub struct ToF32Node(Node<ConverterLogic<fn(&AudioChunk) -> AudioChunk>>);
 
 impl ToF32Node {
-    pub fn new() -> Box<dyn AudioPipelineNode> {
-        Self::with_channel_size(16)
+    pub fn new() -> Self {
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_f32()), 16))
+    }
+
+    pub fn make() -> Box<dyn AudioPipelineNode> {
+        Self::new().boxed()
     }
 
     pub fn with_channel_size(channel_size: usize) -> Box<dyn AudioPipelineNode> {
-        let logic = ConverterLogic::new(|chunk: &AudioChunk| chunk.to_f32());
-        Box::new(Node::new_with_input(logic, channel_size))
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_f32()), channel_size)).boxed()
     }
 }
 
 impl Default for ToF32Node {
     fn default() -> Self {
-        Self
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl AudioPipelineNode for ToF32Node {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> { self.0.get_tx() }
+    fn register(&mut self, child: Box<dyn AudioPipelineNode>) { self.0.register(child) }
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.0).run(stop_token).await
     }
 }
 
 /// Node de conversion vers F64 (64-bit floating point)
-pub struct ToF64Node;
+pub struct ToF64Node(Node<ConverterLogic<fn(&AudioChunk) -> AudioChunk>>);
 
 impl ToF64Node {
-    pub fn new() -> Box<dyn AudioPipelineNode> {
-        Self::with_channel_size(16)
+    pub fn new() -> Self {
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_f64()), 16))
+    }
+
+    pub fn make() -> Box<dyn AudioPipelineNode> {
+        Self::new().boxed()
     }
 
     pub fn with_channel_size(channel_size: usize) -> Box<dyn AudioPipelineNode> {
-        let logic = ConverterLogic::new(|chunk: &AudioChunk| chunk.to_f64());
-        Box::new(Node::new_with_input(logic, channel_size))
+        Self(Node::new_with_input(ConverterLogic::new(|chunk: &AudioChunk| chunk.to_f64()), channel_size)).boxed()
     }
 }
 
 impl Default for ToF64Node {
     fn default() -> Self {
-        Self
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl AudioPipelineNode for ToF64Node {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> { self.0.get_tx() }
+    fn register(&mut self, child: Box<dyn AudioPipelineNode>) { self.0.register(child) }
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.0).run(stop_token).await
     }
 }
 
diff --git a/pmoaudio/src/nodes/file_source.rs b/pmoaudio/src/nodes/file_source.rs
index ccd7bf07..ff5de77c 100755
--- a/pmoaudio/src/nodes/file_source.rs
+++ b/pmoaudio/src/nodes/file_source.rs
@@ -224,18 +224,21 @@ impl FileSource {
     ///
     /// * `path` - chemin du fichier audio à lire
     pub fn new<P: Into<PathBuf>>(path: P) -> Self {
-        Self::with_chunk_size(path, 0) // 0 = auto-calculer
+        let logic = FileSourceLogic::new(path, 0);
+        Self { inner: Node::new_source(logic) }
+    }
+
+    pub fn make<P: Into<PathBuf>>(path: P) -> Box<dyn AudioPipelineNode> {
+        Self::new(path).boxed()
     }
 
     /// Crée une nouvelle source de fichier avec une taille de chunk spécifique.
     ///
     /// * `path` - chemin du fichier audio à lire
     /// * `chunk_frames` - nombre d'échantillons par canal par chunk (0 = auto)
-    pub fn with_chunk_size<P: Into<PathBuf>>(path: P, chunk_frames: usize) -> Self {
+    pub fn with_chunk_size<P: Into<PathBuf>>(path: P, chunk_frames: usize) -> Box<dyn AudioPipelineNode> {
         let logic = FileSourceLogic::new(path, chunk_frames);
-        Self {
-            inner: Node::new_source(logic),
-        }
+        Self { inner: Node::new_source(logic) }.boxed()
     }
 }
 
diff --git a/pmoaudio/src/nodes/flac_file_sink.rs b/pmoaudio/src/nodes/flac_file_sink.rs
index 8b22d8d3..124b6ad5 100755
--- a/pmoaudio/src/nodes/flac_file_sink.rs
+++ b/pmoaudio/src/nodes/flac_file_sink.rs
@@ -305,7 +305,12 @@ impl FlacFileSink {
     /// * `base_path` - Chemin de base pour les fichiers FLAC. Si des TrackBoundary sont reçus,
     ///   des fichiers seront créés avec des suffixes (_01, _02, etc.)
     pub fn new<P: Into<PathBuf>>(base_path: P) -> Self {
-        Self::with_channel_size(base_path, DEFAULT_CHANNEL_SIZE)
+        let logic = FlacFileSinkLogic::new(base_path, EncoderOptions::default(), 8);
+        Self { inner: Node::new_with_input(logic, DEFAULT_CHANNEL_SIZE) }
+    }
+
+    pub fn make<P: Into<PathBuf>>(base_path: P) -> Box<dyn AudioPipelineNode> {
+        Self::new(base_path).boxed()
     }
 
     /// Crée un sink FLAC avec une taille de buffer MPSC personnalisée.
@@ -314,8 +319,9 @@ impl FlacFileSink {
     ///
     /// * `base_path` - Chemin de base pour les fichiers FLAC
     /// * `channel_size` - Taille du buffer MPSC (nombre de segments en attente avant backpressure)
-    pub fn with_channel_size<P: Into<PathBuf>>(base_path: P, channel_size: usize) -> Self {
-        Self::with_config(base_path, channel_size, EncoderOptions::default())
+    pub fn with_channel_size<P: Into<PathBuf>>(base_path: P, channel_size: usize) -> Box<dyn AudioPipelineNode> {
+        let logic = FlacFileSinkLogic::new(base_path, EncoderOptions::default(), 8);
+        Self { inner: Node::new_with_input(logic, channel_size) }.boxed()
     }
 
     /// Crée un sink FLAC avec une configuration complète.
@@ -329,11 +335,11 @@ impl FlacFileSink {
         base_path: P,
         channel_size: usize,
         encoder_options: EncoderOptions,
-    ) -> Self {
+    ) -> Box<dyn AudioPipelineNode> {
         let logic = FlacFileSinkLogic::new(base_path, encoder_options, 8);
         Self {
             inner: Node::new_with_input(logic, channel_size),
-        }
+        }.boxed()
     }
 }
 
diff --git a/pmoaudio/src/nodes/http_source.rs b/pmoaudio/src/nodes/http_source.rs
index b6718336..3ca51ae3 100755
--- a/pmoaudio/src/nodes/http_source.rs
+++ b/pmoaudio/src/nodes/http_source.rs
@@ -297,7 +297,12 @@ impl HttpSource {
     /// let source = HttpSource::new("http://example.com/music.flac");
     /// ```
     pub fn new<S: Into<String>>(url: S) -> Self {
-        Self::with_chunk_size(url, 0)
+        let logic = HttpSourceLogic::new(url.into(), 0);
+        Self { inner: Node::new_source(logic) }
+    }
+
+    pub fn make<S: Into<String>>(url: S) -> Box<dyn AudioPipelineNode> {
+        Self::new(url).boxed()
     }
 
     /// Crée une nouvelle source HTTP avec une taille de chunk spécifique.
@@ -315,11 +320,9 @@ impl HttpSource {
     /// // Utiliser des chunks de 2048 frames
     /// let source = HttpSource::with_chunk_size("http://example.com/music.mp3", 2048);
     /// ```
-    pub fn with_chunk_size<S: Into<String>>(url: S, chunk_frames: usize) -> Self {
+    pub fn with_chunk_size<S: Into<String>>(url: S, chunk_frames: usize) -> Box<dyn AudioPipelineNode> {
         let logic = HttpSourceLogic::new(url.into(), chunk_frames);
-        Self {
-            inner: Node::new_source(logic),
-        }
+        Self { inner: Node::new_source(logic) }.boxed()
     }
 
     pub fn get_url(&self) -> String {
diff --git a/pmoaudio/src/nodes/mod.rs b/pmoaudio/src/nodes/mod.rs
index ddb694cf..83ffcbfc 100755
--- a/pmoaudio/src/nodes/mod.rs
+++ b/pmoaudio/src/nodes/mod.rs
@@ -27,6 +27,7 @@ pub mod http_source;
 pub mod resampling_node;
 pub mod timer_buffer_node;
 pub mod timer_node;
+pub mod position_tracker_node;
 
 // Modules temporairement désactivés
 /*
diff --git a/pmoaudio/src/nodes/position_tracker_node.rs b/pmoaudio/src/nodes/position_tracker_node.rs
new file mode 100644
index 00000000..6e9cdd0f
--- /dev/null
+++ b/pmoaudio/src/nodes/position_tracker_node.rs
@@ -0,0 +1,127 @@
+//! PositionTrackerNode — nœud transparent de suivi de position.
+//!
+//! Laisse passer tous les segments sans modification, et maintient
+//! un compteur de position courant basé sur le `timestamp_sec` des chunks.
+//!
+//! Placé après un `TimerBufferNode`, il reflète la position de l'audio
+//! effectivement sorti du buffer, pas celui encore en attente.
+
+use crate::{
+    nodes::AudioError,
+    pipeline::{send_to_children, AudioPipelineNode, Node, NodeLogic},
+    type_constraints::TypeRequirement,
+    AudioSegment, _AudioSegment,
+};
+use std::sync::{Arc, atomic::{AtomicU64, Ordering}};
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+
+// ─── Handle public ────────────────────────────────────────────────────────────
+
+/// Handle partageable pour lire la position courante.
+#[derive(Clone)]
+pub struct PositionHandle {
+    /// Position encodée en microsecondes dans un AtomicU64 (pas de lock nécessaire).
+    position_us: Arc<AtomicU64>,
+}
+
+impl PositionHandle {
+    /// Retourne la position courante en secondes.
+    pub fn current_position_sec(&self) -> f64 {
+        self.position_us.load(Ordering::Relaxed) as f64 / 1_000_000.0
+    }
+}
+
+// ─── Logique du nœud ─────────────────────────────────────────────────────────
+
+struct PositionTrackerLogic {
+    position_us: Arc<AtomicU64>,
+}
+
+#[async_trait::async_trait]
+impl NodeLogic for PositionTrackerLogic {
+    async fn process(
+        &mut self,
+        input: Option<mpsc::Receiver<Arc<AudioSegment>>>,
+        output: Vec<mpsc::Sender<Arc<AudioSegment>>>,
+        stop_token: CancellationToken,
+    ) -> Result<(), AudioError> {
+        let mut input = input.ok_or_else(|| {
+            AudioError::ProcessingError("PositionTrackerNode requires an input".into())
+        })?;
+
+        loop {
+            tokio::select! {
+                _ = stop_token.cancelled() => break,
+                segment = input.recv() => {
+                    match segment {
+                        None => break,
+                        Some(seg) => {
+                            // Mettre à jour la position sur les chunks audio uniquement
+                            if let _AudioSegment::Chunk(_) = &seg.segment {
+                                let us = (seg.timestamp_sec * 1_000_000.0) as u64;
+                                self.position_us.store(us, Ordering::Relaxed);
+                            }
+                            // Passer le segment sans modification
+                            send_to_children("PositionTrackerNode", &output, seg).await?;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn cleanup(
+        &mut self,
+        _reason: crate::pipeline::StopReason,
+    ) -> Result<(), AudioError> {
+        Ok(())
+    }
+}
+
+// ─── Nœud public ─────────────────────────────────────────────────────────────
+
+pub struct PositionTrackerNode {
+    inner: Node<PositionTrackerLogic>,
+}
+
+impl PositionTrackerNode {
+    pub fn new() -> (Self, PositionHandle) {
+        let position_us = Arc::new(AtomicU64::new(0));
+        let logic = PositionTrackerLogic { position_us: position_us.clone() };
+        let handle = PositionHandle { position_us };
+        let node = Self { inner: Node::new_with_input(logic, 16) };
+        (node, handle)
+    }
+}
+
+#[async_trait::async_trait]
+impl AudioPipelineNode for PositionTrackerNode {
+    fn get_tx(&self) -> Option<mpsc::Sender<Arc<AudioSegment>>> {
+        self.inner.get_tx()
+    }
+
+    fn register(&mut self, child: Box<dyn AudioPipelineNode>) {
+        self.inner.register(child);
+    }
+
+    async fn run(self: Box<Self>, stop_token: CancellationToken) -> Result<(), AudioError> {
+        Box::new(self.inner).run(stop_token).await
+    }
+
+    fn start(self: Box<Self>) -> crate::pipeline::PipelineHandle {
+        Box::new(self.inner).start()
+    }
+}
+
+impl crate::TypedAudioNode for PositionTrackerNode {
+    fn input_type(&self) -> Option<TypeRequirement> {
+        None // Accepte tout
+    }
+
+    fn output_type(&self) -> Option<TypeRequirement> {
+        None // Passe tout
+    }
+}
diff --git a/pmoaudio/src/nodes/resampling_node.rs b/pmoaudio/src/nodes/resampling_node.rs
index 7cbac24b..de17e5bb 100644
--- a/pmoaudio/src/nodes/resampling_node.rs
+++ b/pmoaudio/src/nodes/resampling_node.rs
@@ -333,8 +333,13 @@ impl ResamplingNode {
     /// Crée un nouveau node de resampling
     ///
     /// * `target_sample_rate` - Sample rate de sortie en Hz (ex: 48000)
-    pub fn new(target_sample_rate: u32) -> Box<dyn AudioPipelineNode> {
-        Self::with_channel_size(target_sample_rate, 16)
+    pub fn new(target_sample_rate: u32) -> Self {
+        let logic = ResamplingLogic::new(target_sample_rate);
+        Self { inner: Node::new_with_input(logic, 16) }
+    }
+
+    pub fn make(target_sample_rate: u32) -> Box<dyn AudioPipelineNode> {
+        Self::new(target_sample_rate).boxed()
     }
 
     /// Crée un nouveau node de resampling avec taille de canal personnalisée
@@ -346,9 +351,7 @@ impl ResamplingNode {
         channel_size: usize,
     ) -> Box<dyn AudioPipelineNode> {
         let logic = ResamplingLogic::new(target_sample_rate);
-        Box::new(Self {
-            inner: Node::new_with_input(logic, channel_size),
-        })
+        Self { inner: Node::new_with_input(logic, channel_size) }.boxed()
     }
 }
 
diff --git a/pmoaudio/src/nodes/timer_buffer_node.rs b/pmoaudio/src/nodes/timer_buffer_node.rs
index f35b4c1b..756b9979 100644
--- a/pmoaudio/src/nodes/timer_buffer_node.rs
+++ b/pmoaudio/src/nodes/timer_buffer_node.rs
@@ -135,6 +135,14 @@ impl TimerBufferNodeLogic {
                 self.buffer.len()
             );
 
+            if self.buffer.is_empty() && self.buffered_time_sec < self.capacity_sec * 0.1 {
+                tracing::warn!(
+                    "TimerBufferNode: buffer underrun at ts={:.3}s (capacity={:.1}s) — source too slow or stalled",
+                    segment.timestamp_sec,
+                    self.capacity_sec,
+                );
+            }
+
             send_to_children(std::any::type_name::<Self>(), output, segment).await?;
         }
         Ok(())
@@ -305,7 +313,12 @@ impl TimerBufferNode {
     /// let buffer = TimerBufferNode::new(3.0);
     /// ```
     pub fn new(capacity_sec: f64) -> Self {
-        Self::with_channel_size(capacity_sec, DEFAULT_CHANNEL_SIZE)
+        let logic = TimerBufferNodeLogic::new(capacity_sec);
+        Self { inner: Node::new_with_input(logic, DEFAULT_CHANNEL_SIZE) }
+    }
+
+    pub fn make(capacity_sec: f64) -> Box<dyn AudioPipelineNode> {
+        Self::new(capacity_sec).boxed()
     }
 
     /// Crée un TimerBufferNode avec une taille de buffer MPSC personnalisée
@@ -314,11 +327,9 @@ impl TimerBufferNode {
     ///
     /// * `capacity_sec` - Capacité du buffer en secondes
     /// * `channel_size` - Taille du buffer MPSC (nombre de segments en attente)
-    pub fn with_channel_size(capacity_sec: f64, channel_size: usize) -> Self {
+    pub fn with_channel_size(capacity_sec: f64, channel_size: usize) -> Box<dyn AudioPipelineNode> {
         let logic = TimerBufferNodeLogic::new(capacity_sec);
-        Self {
-            inner: Node::new_with_input(logic, channel_size),
-        }
+        Self { inner: Node::new_with_input(logic, channel_size) }.boxed()
     }
 }
 
diff --git a/pmoaudio/src/nodes/timer_node.rs b/pmoaudio/src/nodes/timer_node.rs
index bc005153..92ceda9c 100644
--- a/pmoaudio/src/nodes/timer_node.rs
+++ b/pmoaudio/src/nodes/timer_node.rs
@@ -308,7 +308,12 @@ impl TimerNode {
     /// let timer = TimerNode::new(3.0);
     /// ```
     pub fn new(max_lead_time_sec: f64) -> Self {
-        Self::with_channel_size(max_lead_time_sec, DEFAULT_CHANNEL_SIZE)
+        let logic = TimerNodeLogic::new(max_lead_time_sec);
+        Self { inner: Node::new_with_input(logic, DEFAULT_CHANNEL_SIZE) }
+    }
+
+    pub fn make(max_lead_time_sec: f64) -> Box<dyn AudioPipelineNode> {
+        Self::new(max_lead_time_sec).boxed()
     }
 
     /// Crée un TimerNode avec une taille de buffer MPSC personnalisée
@@ -317,11 +322,9 @@ impl TimerNode {
     ///
     /// * `max_lead_time_sec` - Avance maximale en secondes
     /// * `channel_size` - Taille du buffer MPSC (nombre de segments en attente)
-    pub fn with_channel_size(max_lead_time_sec: f64, channel_size: usize) -> Self {
+    pub fn with_channel_size(max_lead_time_sec: f64, channel_size: usize) -> Box<dyn AudioPipelineNode> {
         let logic = TimerNodeLogic::new(max_lead_time_sec);
-        Self {
-            inner: Node::new_with_input(logic, channel_size),
-        }
+        Self { inner: Node::new_with_input(logic, channel_size) }.boxed()
     }
 }
 
diff --git a/pmoaudio/src/pipeline.rs b/pmoaudio/src/pipeline.rs
index eac59ebf..164fc481 100755
--- a/pmoaudio/src/pipeline.rs
+++ b/pmoaudio/src/pipeline.rs
@@ -82,6 +82,14 @@ pub trait AudioPipelineNode: Send + 'static {
     /// Le parent extrait le tx via `child.get_tx()` avant de stocker le child.
     fn register(&mut self, child: Box<dyn AudioPipelineNode>);
 
+    /// Encapsule ce nœud dans un `Box<dyn AudioPipelineNode>` pour l'utiliser dans un pipeline.
+    fn boxed(self) -> Box<dyn AudioPipelineNode>
+    where
+        Self: Sized + 'static,
+    {
+        Box::new(self)
+    }
+
     /// Lance le nœud et tous ses enfants
     ///
     /// # Arguments
diff --git a/pmoaudiocache/src/streaming.rs b/pmoaudiocache/src/streaming.rs
index 53d98779..c93ddc3e 100644
--- a/pmoaudiocache/src/streaming.rs
+++ b/pmoaudiocache/src/streaming.rs
@@ -125,6 +125,7 @@ fn codec_to_string(codec: AudioCodec) -> String {
         AudioCodec::OggOpus => "ogg_opus",
         AudioCodec::Wav => "wav",
         AudioCodec::Aiff => "aiff",
+        AudioCodec::Aac => "aac",
     }
     .to_string()
 }
diff --git a/pmocontrol/src/music_renderer/musicrenderer.rs b/pmocontrol/src/music_renderer/musicrenderer.rs
index a265f6d8..4de6e33b 100644
--- a/pmocontrol/src/music_renderer/musicrenderer.rs
+++ b/pmocontrol/src/music_renderer/musicrenderer.rs
@@ -550,8 +550,8 @@ impl MusicRenderer {
                 .map(|prev| !playback_state_equal(prev, &raw_state))
                 .unwrap_or(true);
 
-            // Emit event only for non-transient states to reduce noise
-            if changed && !matches!(raw_state, PlaybackState::Transitioning) {
+            // Emit event for all state changes including Transitioning
+            if changed {
                 let state_clone = raw_state.clone();
                 drop(watched);
                 self.emit_event(RendererEvent::StateChanged {
diff --git a/pmoflac/Cargo.toml b/pmoflac/Cargo.toml
index 9919892e..c23460ea 100755
--- a/pmoflac/Cargo.toml
+++ b/pmoflac/Cargo.toml
@@ -19,6 +19,7 @@ libflac-sys = { version = "0.3.3", default-features = false, features = ["build-
 lofty = "0.22"
 minimp3 = "0.5"
 opus = "0.3"
+fdk-aac = "0.8"
 pmometadata = { path = "../pmometadata" }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "sync", "io-util", "fs"] }
diff --git a/pmoflac/src/aac.rs b/pmoflac/src/aac.rs
new file mode 100644
index 00000000..67a71184
--- /dev/null
+++ b/pmoflac/src/aac.rs
@@ -0,0 +1,177 @@
+//! AAC Decoder Module (ADTS streaming)
+//!
+//! Provides asynchronous streaming AAC/ADTS decoding via libfdk-aac (statically linked).
+//! Decodes AAC audio streams into PCM data (16-bit little-endian interleaved).
+//!
+//! Designed for live radio streams (e.g. Radio France icecast AAC 192kbps).
+//! No seek required — pure linear streaming.
+//!
+//! ## Architecture
+//!
+//! ```text
+//! AAC Input → [Ingest Task] → [Decode Task (blocking)] → [Writer Task] → PCM Output (AsyncRead)
+//! ```
+
+use fdk_aac::dec::{Decoder, DecoderError, Transport};
+use tokio::{
+    io::AsyncRead,
+    sync::{mpsc, oneshot},
+};
+
+use crate::{
+    common::ChannelReader,
+    decoder_common::{
+        spawn_ingest_task, spawn_writer_task, DecodedStream, DecoderError as PmoDecoderError,
+        CHANNEL_CAPACITY, DUPLEX_BUFFER_SIZE,
+    },
+    pcm::StreamInfo,
+    stream::ManagedAsyncReader,
+};
+
+/// Errors that can occur while decoding AAC data.
+pub type AacError = PmoDecoderError;
+
+/// Async decoded AAC stream.
+pub type AacDecodedStream = DecodedStream<AacError>;
+
+/// Decodes an AAC/ADTS stream into PCM audio data (16-bit little-endian interleaved).
+///
+/// The input must be a raw ADTS stream (as produced by Radio France icecast).
+/// No seek is required — the decoder processes frames linearly.
+pub async fn decode_aac_stream<R>(reader: R) -> Result<AacDecodedStream, AacError>
+where
+    R: AsyncRead + Unpin + Send + 'static,
+{
+    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);
+        let mut decoder = Decoder::new(Transport::Adts);
+        let mut info_tx = Some(info_tx);
+
+        // Buffer de lecture — on lit des chunks et on les pousse au décodeur
+        let mut read_buf = vec![0u8; 8192];
+        // Buffer de sortie PCM — fdk-aac écrit des frames entières
+        let mut pcm_out = vec![0i16; 8192];
+
+        use std::io::Read;
+
+        loop {
+            // Lire des bytes depuis le stream ADTS
+            let n = match channel_reader.read(&mut read_buf) {
+                Ok(0) => break, // EOF
+                Ok(n) => n,
+                Err(e) => {
+                    let err = AacError::Io {
+                        kind: e.kind(),
+                        message: e.to_string(),
+                    };
+                    if let Some(tx) = info_tx.take() {
+                        let _ = tx.send(Err(err.clone()));
+                    }
+                    return Err(err);
+                }
+            };
+
+            // Pousser les bytes au décodeur fdk-aac
+            let filled = match decoder.fill(&read_buf[..n]) {
+                Ok(filled) => filled,
+                Err(e) => {
+                    let err = AacError::Decode(format!("fdk-aac fill error: {:?}", e));
+                    if let Some(tx) = info_tx.take() {
+                        let _ = tx.send(Err(err.clone()));
+                    }
+                    return Err(err);
+                }
+            };
+
+            // Si fill n'a pas consommé tous les bytes, on les remet devant
+            // (fdk-aac peut ne pas consommer tout en une passe)
+            // Note: fdk-aac retourne le nombre de bytes non-consommés — on les ignore
+            // car le décodeur conserve son état interne entre appels.
+            let _ = filled;
+
+            // Décoder les frames disponibles
+            loop {
+                // Adapter la taille du buffer PCM si nécessaire
+                let stream_info = decoder.stream_info();
+                let frame_size = if stream_info.frameSize > 0 && stream_info.numChannels > 0 {
+                    (stream_info.frameSize * stream_info.numChannels) as usize
+                } else {
+                    2048 // taille par défaut avant la première frame
+                };
+
+                if pcm_out.len() < frame_size {
+                    pcm_out.resize(frame_size, 0i16);
+                }
+
+                match decoder.decode_frame(&mut pcm_out) {
+                    Ok(()) => {
+                        let info_ref = decoder.stream_info();
+
+                        // Envoyer les infos au premier décodage réussi
+                        if let Some(tx) = info_tx.take() {
+                            let info = StreamInfo {
+                                sample_rate: info_ref.sampleRate as u32,
+                                channels: info_ref.numChannels as u8,
+                                bits_per_sample: 16,
+                                total_samples: None,
+                                max_block_size: 0,
+                                min_block_size: 0,
+                            };
+                            if tx.send(Ok(info)).is_err() {
+                                return Ok(());
+                            }
+                        }
+
+                        // Convertir i16 → bytes little-endian
+                        let samples = &pcm_out[..frame_size];
+                        let mut bytes = Vec::with_capacity(samples.len() * 2);
+                        for s in samples {
+                            bytes.extend_from_slice(&s.to_le_bytes());
+                        }
+
+                        if pcm_tx.blocking_send(Ok(bytes)).is_err() {
+                            return Ok(());
+                        }
+                    }
+                    Err(DecoderError::NOT_ENOUGH_BITS) => {
+                        // Pas assez de données — besoin de plus d'input
+                        break;
+                    }
+                    Err(DecoderError::TRANSPORT_SYNC_ERROR) => {
+                        // Erreur de sync ADTS transitoire — continuer
+                        break;
+                    }
+                    Err(e) => {
+                        let err = AacError::Decode(format!("fdk-aac decode error: {:?}", e));
+                        if let Some(tx) = info_tx.take() {
+                            let _ = tx.send(Err(err.clone()));
+                        }
+                        return Err(err);
+                    }
+                }
+            }
+        }
+
+        if let Some(tx) = info_tx.take() {
+            let err = AacError::Decode("AAC stream contained no decodable frames".into());
+            let _ = tx.send(Err(err.clone()));
+            return Err(err);
+        }
+
+        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))
+}
diff --git a/pmoflac/src/autodetect.rs b/pmoflac/src/autodetect.rs
index dd1f551f..1c5f6a61 100755
--- a/pmoflac/src/autodetect.rs
+++ b/pmoflac/src/autodetect.rs
@@ -7,6 +7,7 @@ use std::{
 use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
 
 use crate::{
+    aac::{decode_aac_stream, AacDecodedStream, AacError},
     decode_aiff_stream, decode_flac_stream, decode_mp3_stream, decode_ogg_opus_stream,
     decode_ogg_vorbis_stream, decode_wav_stream, pcm::StreamInfo, prefixed_reader::PrefixedReader,
     AiffDecodedStream, AiffError, FlacDecodedStream, FlacError, Mp3DecodedStream, Mp3Error,
@@ -34,6 +35,8 @@ pub enum DecodeAudioError {
     Wav(WavError),
     #[error("AIFF decode error: {0}")]
     Aiff(AiffError),
+    #[error("AAC decode error: {0}")]
+    Aac(AacError),
 }
 
 pub async fn decode_audio_stream<R>(reader: R) -> Result<DecodedAudioStream, DecodeAudioError>
@@ -94,6 +97,12 @@ where
                 .map_err(DecodeAudioError::Aiff)?;
             DecodedAudioStream::Aiff(stream)
         }
+        DetectedFormat::Aac => {
+            let stream = decode_aac_stream(prefixed)
+                .await
+                .map_err(DecodeAudioError::Aac)?;
+            DecodedAudioStream::Aac(stream)
+        }
     };
 
     Ok(stream)
@@ -106,6 +115,7 @@ pub enum DecodedAudioStream {
     OggOpus(OggOpusDecodedStream),
     Wav(WavDecodedStream),
     Aiff(AiffDecodedStream),
+    Aac(AacDecodedStream),
 }
 
 impl DecodedAudioStream {
@@ -117,6 +127,7 @@ impl DecodedAudioStream {
             DecodedAudioStream::OggOpus(inner) => inner.info(),
             DecodedAudioStream::Wav(inner) => inner.info(),
             DecodedAudioStream::Aiff(inner) => inner.info(),
+            DecodedAudioStream::Aac(inner) => inner.info(),
         }
     }
 
@@ -132,6 +143,7 @@ impl DecodedAudioStream {
             }
             DecodedAudioStream::Wav(inner) => inner.wait().await.map_err(DecodeAudioError::Wav),
             DecodedAudioStream::Aiff(inner) => inner.wait().await.map_err(DecodeAudioError::Aiff),
+            DecodedAudioStream::Aac(inner) => inner.wait().await.map_err(DecodeAudioError::Aac),
         }
     }
 
@@ -161,6 +173,10 @@ impl DecodedAudioStream {
                 let (info, reader) = inner.into_parts();
                 (info, DecodedReader::Aiff(reader))
             }
+            DecodedAudioStream::Aac(inner) => {
+                let (info, reader) = inner.into_parts();
+                (info, DecodedReader::Aac(reader))
+            }
         }
     }
 }
@@ -178,6 +194,7 @@ impl AsyncRead for DecodedAudioStream {
             DecodedAudioStream::OggOpus(inner) => Pin::new(inner).poll_read(cx, buf),
             DecodedAudioStream::Wav(inner) => Pin::new(inner).poll_read(cx, buf),
             DecodedAudioStream::Aiff(inner) => Pin::new(inner).poll_read(cx, buf),
+            DecodedAudioStream::Aac(inner) => Pin::new(inner).poll_read(cx, buf),
         }
     }
 }
@@ -189,6 +206,7 @@ pub enum DecodedReader {
     OggOpus(crate::stream::ManagedAsyncReader<OggOpusError>),
     Wav(crate::stream::ManagedAsyncReader<WavError>),
     Aiff(crate::stream::ManagedAsyncReader<AiffError>),
+    Aac(crate::stream::ManagedAsyncReader<AacError>),
 }
 
 impl DecodedReader {
@@ -200,6 +218,7 @@ impl DecodedReader {
             DecodedReader::OggOpus(inner) => inner.wait().await.map_err(DecodeAudioError::Opus),
             DecodedReader::Wav(inner) => inner.wait().await.map_err(DecodeAudioError::Wav),
             DecodedReader::Aiff(inner) => inner.wait().await.map_err(DecodeAudioError::Aiff),
+            DecodedReader::Aac(inner) => inner.wait().await.map_err(DecodeAudioError::Aac),
         }
     }
 }
@@ -217,6 +236,7 @@ impl AsyncRead for DecodedReader {
             DecodedReader::OggOpus(inner) => Pin::new(inner).poll_read(cx, buf),
             DecodedReader::Wav(inner) => Pin::new(inner).poll_read(cx, buf),
             DecodedReader::Aiff(inner) => Pin::new(inner).poll_read(cx, buf),
+            DecodedReader::Aac(inner) => Pin::new(inner).poll_read(cx, buf),
         }
     }
 }
@@ -242,12 +262,29 @@ fn detect_format(bytes: &[u8]) -> Option<DetectedFormat> {
     if let Some(fmt) = detect_ogg(bytes) {
         return Some(fmt);
     }
+    // Tester AAC avant MP3 : ADTS (0xFF 0xF0/0xF8) est un sous-ensemble du syncword MP3
+    // (0xFF 0xEx), donc la détection MP3 absorberait les flux AAC si elle passait en premier.
+    if is_adts_aac(bytes) {
+        return Some(DetectedFormat::Aac);
+    }
     if is_mp3(bytes) {
         return Some(DetectedFormat::Mp3);
     }
     None
 }
 
+/// Détecte un flux AAC ADTS : syncword 0xFFF (12 bits) + layer = 00.
+/// Structure du 2e octet : 1111 VLLL → V=version, L=layer(00 pour AAC), P=protection
+/// MP3 a layer != 00 (01=III, 10=II, 11=I), AAC ADTS a layer == 00.
+fn is_adts_aac(bytes: &[u8]) -> bool {
+    if bytes.len() < 2 {
+        return false;
+    }
+    // syncword = 0xFFF (12 bits) : byte0=0xFF, byte1[7:4]=0xF
+    // layer = byte1[2:1] == 0b00 (distingue AAC de MP3)
+    bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0
+}
+
 fn detect_ogg(bytes: &[u8]) -> Option<DetectedFormat> {
     if bytes.len() < 27 || &bytes[..4] != b"OggS" {
         return None;
@@ -294,4 +331,5 @@ enum DetectedFormat {
     OggOpus,
     Wav,
     Aiff,
+    Aac,
 }
diff --git a/pmoflac/src/lib.rs b/pmoflac/src/lib.rs
index aeaf58e3..a74a741a 100755
--- a/pmoflac/src/lib.rs
+++ b/pmoflac/src/lib.rs
@@ -95,6 +95,7 @@
 //! }
 //! ```
 
+pub mod aac;
 pub mod aiff;
 pub mod autodetect;
 mod common;
@@ -114,6 +115,7 @@ pub mod transcode;
 mod util;
 pub mod wav;
 
+pub use aac::{decode_aac_stream, AacDecodedStream, AacError};
 pub use aiff::{decode_aiff_stream, AiffDecodedStream, AiffError};
 pub use autodetect::{
     decode_audio_stream, is_flac_magic_header, DecodeAudioError, DecodedAudioStream, DecodedReader,
diff --git a/pmoflac/src/transcode.rs b/pmoflac/src/transcode.rs
index 685da1fe..822f0be3 100755
--- a/pmoflac/src/transcode.rs
+++ b/pmoflac/src/transcode.rs
@@ -31,6 +31,7 @@ pub enum AudioCodec {
     OggOpus,
     Wav,
     Aiff,
+    Aac,
 }
 
 /// Options controlling how the transcoder operates.
@@ -195,6 +196,9 @@ where
         DecodedAudioStream::Aiff(stream) => {
             transcode_from_decoded(AudioCodec::Aiff, stream, options.encoder_options).await
         }
+        DecodedAudioStream::Aac(stream) => {
+            transcode_from_decoded(AudioCodec::Aac, stream, options.encoder_options).await
+        }
     }
 }
 
diff --git a/pmoflac/tests/aac_decode.rs b/pmoflac/tests/aac_decode.rs
new file mode 100644
index 00000000..5f7c6ab7
--- /dev/null
+++ b/pmoflac/tests/aac_decode.rs
@@ -0,0 +1,43 @@
+use pmoflac::decode_aac_stream;
+use tokio::io::AsyncReadExt;
+
+#[tokio::test]
+async fn test_decode_adts_file() {
+    let file = tokio::fs::File::open("/tmp/test_adts.aac")
+        .await
+        .expect("test ADTS file not found — run: ffmpeg -i tests/SBRtestStereoHiBr.mp4 -vn -acodec copy -f adts /tmp/test_adts.aac");
+
+    let mut stream = decode_aac_stream(file)
+        .await
+        .expect("decode_aac_stream failed");
+
+    let info = stream.info().clone();
+    println!("StreamInfo: {} Hz, {} ch, {} bps", info.sample_rate, info.channels, info.bits_per_sample);
+
+    assert!(info.sample_rate > 0, "sample_rate should be > 0");
+    assert!(info.channels == 1 || info.channels == 2, "channels should be 1 or 2");
+    assert_eq!(info.bits_per_sample, 16);
+
+    let mut pcm = Vec::new();
+    stream.read_to_end(&mut pcm).await.expect("read_to_end failed");
+
+    println!("Decoded {} PCM bytes ({} samples)", pcm.len(), pcm.len() / 2);
+    assert!(pcm.len() > 0, "should have decoded some PCM data");
+}
+
+#[tokio::test]
+async fn test_autodetect_adts() {
+    use pmoflac::decode_audio_stream;
+
+    let file = tokio::fs::File::open("/tmp/test_adts.aac")
+        .await
+        .expect("test ADTS file not found");
+
+    let stream = decode_audio_stream(file)
+        .await
+        .expect("decode_audio_stream failed");
+
+    let info = stream.info().clone();
+    println!("Autodetect: {} Hz, {} ch, {} bps", info.sample_rate, info.channels, info.bits_per_sample);
+    assert!(info.sample_rate > 0);
+}
diff --git a/pmoparadise/examples/download_block.rs b/pmoparadise/examples/download_block.rs
index a5d5f3bb..d5273cea 100644
--- a/pmoparadise/examples/download_block.rs
+++ b/pmoparadise/examples/download_block.rs
@@ -117,7 +117,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let sink = FlacFileSink::new(&base_path);
 
     // Construire la chaîne: source → sink
-    source.register(Box::new(sink));
+    source.register(sink.boxed());
 
     // Créer un token d'arrêt
     let stop_token = CancellationToken::new();
diff --git a/pmoparadise/examples/play_and_cache.rs b/pmoparadise/examples/play_and_cache.rs
index b0ce7f77..a55c782e 100644
--- a/pmoparadise/examples/play_and_cache.rs
+++ b/pmoparadise/examples/play_and_cache.rs
@@ -217,15 +217,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let audio_sink = if use_null_audio {
         AudioSink::with_null_output()
     } else {
-        AudioSink::new()
+        AudioSink::make()
     };
     tracing::debug!("AudioSink created");
 
     // Connecter timer → audio (AVANT de mettre timer dans une Box)
-    timer.register(Box::new(audio_sink));
+    timer.register(audio_sink);
 
     // Connecter playlist → timer
-    playlist_source.register(Box::new(timer));
+    playlist_source.register(timer.boxed());
     tracing::info!("Playback pipeline connected: PlaylistSource → TimerNode → AudioSink");
 
     // ═══════════════════════════════════════════════════════════════════════════
diff --git a/pmoradiofrance/src/source.rs b/pmoradiofrance/src/source.rs
index 84bf3d51..b9e87789 100644
--- a/pmoradiofrance/src/source.rs
+++ b/pmoradiofrance/src/source.rs
@@ -69,8 +69,7 @@ impl RadioFranceSource {
         let cover_cache = pmoupnp::cache_registry::get_cover_cache()
             .ok_or_else(|| crate::error::Error::Other("Cover cache not initialized".to_string()))?;
 
-        // TODO: Récupérer server_base_url depuis config
-        let server_base_url = "http://localhost:8080".to_string();
+        let server_base_url = config.get_base_url();
 
         let metadata_cache = Arc::new(MetadataCache::new(
             client,
diff --git a/pmoserver/src/lib.rs b/pmoserver/src/lib.rs
index 78f763fa..9f3e60fa 100644
--- a/pmoserver/src/lib.rs
+++ b/pmoserver/src/lib.rs
@@ -192,6 +192,20 @@ pub fn get_server() -> Option<Arc<RwLock<Server>>> {
 ///     println!("Stream available at: {}", stream_url);
 /// }
 /// ```
+/// Récupère l'URL de base effective pour une requête donnée.
+///
+/// Utilise les headers `X-Forwarded-*` si présents (accès via reverse proxy),
+/// sinon fallback sur l'URL de base configurée (accès local direct).
+pub fn get_request_base_url(headers: &axum::http::HeaderMap) -> Option<String> {
+    GLOBAL_SERVER.get().map(|server| {
+        if let Ok(srv) = server.try_read() {
+            srv.request_base_url(headers)
+        } else {
+            futures::executor::block_on(async { server.read().await.request_base_url(headers) })
+        }
+    })
+}
+
 pub fn get_server_base_url() -> Option<String> {
     GLOBAL_SERVER.get().map(|server| {
         // Utiliser try_read() pour éviter de bloquer
diff --git a/pmoserver/src/server.rs b/pmoserver/src/server.rs
index 19f05ac3..a2e6c734 100644
--- a/pmoserver/src/server.rs
+++ b/pmoserver/src/server.rs
@@ -615,6 +615,30 @@ impl Server {
         self.join_handle.take()
     }
 
+    /// Retourne l'URL de base vue par le client pour une requête donnée.
+    ///
+    /// Priorité : headers `X-Forwarded-Proto` + `X-Forwarded-Host` (présents
+    /// quand la requête passe par un reverse proxy comme NPM), sinon fallback
+    /// sur `self.base_url()`. Cela permet de générer des URLs correctes aussi
+    /// bien en accès local direct qu'en accès public via proxy.
+    pub fn request_base_url(&self, headers: &axum::http::HeaderMap) -> String {
+        let proto = headers
+            .get("x-forwarded-proto")
+            .and_then(|v| v.to_str().ok())
+            .and_then(|v| v.split(',').next())
+            .map(str::trim);
+        let host = headers
+            .get("x-forwarded-host")
+            .or_else(|| headers.get("host"))
+            .and_then(|v| v.to_str().ok())
+            .map(str::trim);
+
+        match (proto, host) {
+            (Some(proto), Some(host)) => format!("{}://{}", proto, host),
+            _ => self.base_url(),
+        }
+    }
+
     /// Retourne l'URL de base complète du serveur (schéma + hôte + port).
     ///
     /// La valeur configurable peut omettre le schéma ou le port ; cette méthode
diff --git a/pmowebrenderer/Cargo.toml b/pmowebrenderer/Cargo.toml
index 7d83475c..6809822b 100644
--- a/pmowebrenderer/Cargo.toml
+++ b/pmowebrenderer/Cargo.toml
@@ -1,24 +1,33 @@
-	[package]
-	name = "pmowebrenderer"
-	version = "0.1.0"
-	edition = "2021"
+[package]
+name = "pmowebrenderer"
+version = "0.1.0"
+edition = "2021"
 
-	[dependencies]
-	pmoupnp = { path = "../pmoupnp" }
-	pmomediarenderer = { path = "../pmomediarenderer" }
-	pmoserver = { path = "../pmoserver", optional = true }
-	pmocontrol = { path = "../pmocontrol", optional = true }
-	pmoconfig = { path = "../pmoconfig" }
+[dependencies]
+pmoupnp = { path = "../pmoupnp" }
+pmomediarenderer = { path = "../pmomediarenderer" }
+pmoserver = { path = "../pmoserver", optional = true }
+pmocontrol = { path = "../pmocontrol", optional = true }
+pmoconfig = { path = "../pmoconfig" }
+
+# Audio pipeline (toujours actif — c'est le cœur du renderer)
+pmoaudio-ext = { path = "../pmoaudio-ext", features = ["http-stream"] }
+pmoaudio = { path = "../pmoaudio" }
+pmoflac = { path = "../pmoflac" }
+pmometadata = { path = "../pmometadata" }
 
 # Async runtime
 tokio = { workspace = true, features = ["full"] }
+tokio-util = { workspace = true }
 async-trait = { workspace = true }
 
-# WebSocket
-axum = { workspace = true, features = ["ws"] }
+# HTTP
+axum = { workspace = true }
 axum-extra = { version = "0.9", features = ["typed-header"] }
 tower-http = { version = "0.6", features = ["fs", "trace"] }
 futures = "0.3"
+reqwest = { workspace = true, features = ["stream"] }
+bytes = "1.0"
 
 # Serialization
 serde = { workspace = true }
diff --git a/pmowebrenderer/src/config.rs b/pmowebrenderer/src/config.rs
index 8e8c82c6..105330fd 100644
--- a/pmowebrenderer/src/config.rs
+++ b/pmowebrenderer/src/config.rs
@@ -2,21 +2,24 @@
 
 #[cfg(feature = "pmoserver")]
 use std::sync::Arc;
-#[cfg(feature = "pmoserver")]
-use std::time::Duration;
 
 #[cfg(feature = "pmoserver")]
 use async_trait::async_trait;
 
+#[cfg(feature = "pmoserver")]
+use axum::{Router, routing::{delete, get, post}};
+
 #[cfg(feature = "pmoserver")]
 use pmocontrol::ControlPoint;
 
 #[cfg(feature = "pmoserver")]
 use crate::error::WebRendererError;
 #[cfg(feature = "pmoserver")]
-use crate::session::SessionManager;
+use crate::register::{register_handler, unregister_handler};
 #[cfg(feature = "pmoserver")]
-use crate::websocket::{websocket_handler, WebSocketState};
+use crate::registry::RendererRegistry;
+#[cfg(feature = "pmoserver")]
+use crate::stream::stream_handler;
 
 /// Trait pour étendre pmoserver::Server avec les routes WebRenderer
 #[cfg(feature = "pmoserver")]
@@ -35,17 +38,27 @@ impl WebRendererExt for pmoserver::Server {
         &mut self,
         control_point: Arc<ControlPoint>,
     ) -> Result<(), WebRendererError> {
-        let session_manager = Arc::new(SessionManager::new(Duration::from_secs(30 * 60)));
+        let registry = Arc::new(RendererRegistry::new(control_point));
 
-        let ws_state = WebSocketState {
-            session_manager,
-            control_point,
-        };
+        // POST /api/webrenderer/register
+        self.add_post_handler_with_state(
+            "/api/webrenderer/register",
+            register_handler,
+            registry.clone(),
+        )
+        .await;
 
-        self.add_any_handler_with_state("/api/webrenderer/ws", websocket_handler, ws_state)
-            .await;
+        // GET /api/webrenderer/{id}/stream  +  DELETE /api/webrenderer/{id}
+        let dynamic_router = Router::new()
+            .route("/{id}/stream", get(stream_handler))
+            .route("/{id}", delete(unregister_handler))
+            .with_state(registry.clone());
+        self.add_router("/api/webrenderer", dynamic_router).await;
 
-        tracing::info!("WebRenderer WebSocket endpoint registered at /api/webrenderer/ws");
+        tracing::info!("WebRenderer server-side streaming endpoints registered");
+        tracing::info!("  POST   /api/webrenderer/register");
+        tracing::info!("  GET    /api/webrenderer/{{id}}/stream");
+        tracing::info!("  DELETE /api/webrenderer/{{id}}");
         Ok(())
     }
 }
diff --git a/pmowebrenderer/src/handlers.rs b/pmowebrenderer/src/handlers.rs
index 4039573e..48fd08d2 100644
--- a/pmowebrenderer/src/handlers.rs
+++ b/pmowebrenderer/src/handlers.rs
@@ -1,7 +1,7 @@
-//! Action handlers SOAP → WebSocket pour le WebRenderer
+//! Action handlers SOAP → Pipeline pour le WebRenderer serveur
 //!
-//! Chaque handler bridge une action UPnP vers une commande WebSocket
-//! envoyée au navigateur, ou lit l'état partagé pour les requêtes GET.
+//! Chaque handler bridge une action UPnP vers une commande `PipelineControl`
+//! envoyée au pipeline audio serveur, ou lit l'état partagé pour les requêtes GET.
 
 use std::sync::Arc;
 
@@ -10,106 +10,89 @@ use pmoupnp::actions::{ActionData, ActionError, ActionHandler, get_value};
 use pmoupnp::{get, set};
 use pmoutils::ToXmlElement;
 
-use crate::messages::{CommandParams, PlaybackState, ServerMessage, TransportAction};
-use crate::state::{SharedSender, SharedState};
+use crate::messages::PlaybackState;
+use crate::pipeline::{PipelineControl, PipelineHandle, seconds_to_upnp_time, upnp_time_to_seconds};
+use crate::state::SharedState;
 
 type ActionFuture =
     std::pin::Pin<Box<dyn std::future::Future<Output = Result<ActionData, ActionError>> + Send>>;
 
 // ─── AVTransport Handlers ───────────────────────────────────────────────────
 
-pub fn play_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn play_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
-            ws.send(ServerMessage::Command {
-                action: TransportAction::Play,
-                params: None,
-            });
-            state.write().playback_state = PlaybackState::Playing;
+            // Ne pas écrire Playing ici : c'est stream_source qui le fera
+            // une fois que les premiers bytes FLAC ont été produits.
+            // Écrire Transitioning pour signaler que la lecture va démarrer.
+            state.write().playback_state = PlaybackState::Transitioning;
+            pipeline.send(PipelineControl::Play).await;
             Ok(data)
         })
     })
 }
 
-pub fn stop_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn stop_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
-            ws.send(ServerMessage::Command {
-                action: TransportAction::Stop,
-                params: None,
-            });
+            pipeline.send(PipelineControl::Stop).await;
             state.write().playback_state = PlaybackState::Stopped;
             Ok(data)
         })
     })
 }
 
-pub fn pause_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn pause_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
-            ws.send(ServerMessage::Command {
-                action: TransportAction::Pause,
-                params: None,
-            });
+            pipeline.send(PipelineControl::Pause).await;
             state.write().playback_state = PlaybackState::Paused;
             Ok(data)
         })
     })
 }
 
-pub fn next_handler(ws: SharedSender) -> ActionHandler {
+pub fn next_handler(pipeline: PipelineHandle) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         Box::pin(async move {
-            ws.send(ServerMessage::Command {
-                action: TransportAction::Play,
-                params: None,
-            });
+            pipeline.send(PipelineControl::Play).await;
             Ok(data)
         })
     })
 }
 
-pub fn previous_handler(ws: SharedSender) -> ActionHandler {
+pub fn previous_handler(pipeline: PipelineHandle) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         Box::pin(async move {
-            ws.send(ServerMessage::Command {
-                action: TransportAction::Play,
-                params: None,
-            });
+            pipeline.send(PipelineControl::Play).await;
             Ok(data)
         })
     })
 }
 
-pub fn seek_handler(ws: SharedSender) -> ActionHandler {
+pub fn seek_handler(pipeline: PipelineHandle) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         Box::pin(async move {
             let target: String = get!(&data, "Target", String);
-            ws.send(ServerMessage::Command {
-                action: TransportAction::Seek,
-                params: Some(CommandParams {
-                    uri: None,
-                    metadata: None,
-                    position: Some(target),
-                }),
-            });
+            let pos_sec = upnp_time_to_seconds(&target);
+            pipeline.send(PipelineControl::Seek(pos_sec)).await;
             Ok(data)
         })
     })
 }
 
-pub fn set_uri_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn set_uri_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
             let uri: String = get!(&data, "CurrentURI", String);
@@ -119,14 +102,10 @@ pub fn set_uri_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
                         .map(|didl| didl.to_xml())
                 })
                 .unwrap_or_default();
-            ws.send(ServerMessage::Command {
-                action: TransportAction::SetUri,
-                params: Some(CommandParams {
-                    uri: Some(uri.clone()),
-                    metadata: Some(metadata.clone()),
-                    position: None,
-                }),
-            });
+
+            // Envoyer l'URI au pipeline serveur (remplace l'envoi WebSocket)
+            pipeline.send(PipelineControl::LoadUri(uri.clone())).await;
+
             {
                 let mut s = state.write();
                 s.current_uri = Some(uri);
@@ -138,9 +117,9 @@ pub fn set_uri_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
     })
 }
 
-pub fn set_next_uri_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn set_next_uri_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
             let uri: String = get!(&data, "NextURI", String);
@@ -150,14 +129,9 @@ pub fn set_next_uri_handler(ws: SharedSender, state: SharedState) -> ActionHandl
                         .map(|didl| didl.to_xml())
                 })
                 .unwrap_or_default();
-            ws.send(ServerMessage::Command {
-                action: TransportAction::SetNextUri,
-                params: Some(CommandParams {
-                    uri: Some(uri.clone()),
-                    metadata: Some(metadata.clone()),
-                    position: None,
-                }),
-            });
+
+            pipeline.send(PipelineControl::LoadNextUri(uri.clone())).await;
+
             {
                 let mut s = state.write();
                 s.next_uri = Some(uri);
@@ -215,18 +189,14 @@ pub fn get_transport_info_handler(state: SharedState) -> ActionHandler {
         Box::pin(async move {
             let mut data = data;
             let s = state.read();
-            tracing::info!("[WebRenderer] GetTransportInfo handler called, state={:?}", s.playback_state);
+            tracing::info!("[WebRenderer] GetTransportInfo: state={:?}", s.playback_state);
             let transport_state = match s.playback_state {
                 PlaybackState::Stopped => "STOPPED",
                 PlaybackState::Playing => "PLAYING",
                 PlaybackState::Paused => "PAUSED_PLAYBACK",
                 PlaybackState::Transitioning => "TRANSITIONING",
             };
-            set!(
-                &mut data,
-                "CurrentTransportState",
-                transport_state.to_string()
-            );
+            set!(&mut data, "CurrentTransportState", transport_state.to_string());
             set!(&mut data, "CurrentTransportStatus", "OK".to_string());
             set!(&mut data, "CurrentSpeed", "1".to_string());
             Ok(data)
@@ -245,26 +215,10 @@ pub fn get_media_info_handler(state: SharedState) -> ActionHandler {
                 "NrTracks",
                 if s.current_uri.is_some() { 1u32 } else { 0u32 }
             );
-            set!(
-                &mut data,
-                "CurrentURI",
-                s.current_uri.clone().unwrap_or_default()
-            );
-            set!(
-                &mut data,
-                "CurrentURIMetaData",
-                s.current_metadata.clone().unwrap_or_default()
-            );
-            set!(
-                &mut data,
-                "NextURI",
-                s.next_uri.clone().unwrap_or_default()
-            );
-            set!(
-                &mut data,
-                "NextURIMetaData",
-                s.next_metadata.clone().unwrap_or_default()
-            );
+            set!(&mut data, "CurrentURI", s.current_uri.clone().unwrap_or_default());
+            set!(&mut data, "CurrentURIMetaData", s.current_metadata.clone().unwrap_or_default());
+            set!(&mut data, "NextURI", s.next_uri.clone().unwrap_or_default());
+            set!(&mut data, "NextURIMetaData", s.next_metadata.clone().unwrap_or_default());
             Ok(data)
         })
     })
@@ -272,13 +226,13 @@ pub fn get_media_info_handler(state: SharedState) -> ActionHandler {
 
 // ─── RenderingControl Handlers ──────────────────────────────────────────────
 
-pub fn set_volume_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn set_volume_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
             let volume: u16 = get!(&data, "DesiredVolume", u16);
-            ws.send(ServerMessage::SetVolume { volume });
+            pipeline.send(PipelineControl::SetVolume(volume)).await;
             state.write().volume = volume;
             Ok(data)
         })
@@ -297,13 +251,13 @@ pub fn get_volume_handler(state: SharedState) -> ActionHandler {
     })
 }
 
-pub fn set_mute_handler(ws: SharedSender, state: SharedState) -> ActionHandler {
+pub fn set_mute_handler(pipeline: PipelineHandle, state: SharedState) -> ActionHandler {
     Arc::new(move |data: ActionData| -> ActionFuture {
-        let ws = ws.clone();
+        let pipeline = pipeline.clone();
         let state = state.clone();
         Box::pin(async move {
             let mute: bool = get!(&data, "DesiredMute", bool);
-            ws.send(ServerMessage::SetMute { mute });
+            pipeline.send(PipelineControl::SetMute(mute)).await;
             state.write().mute = mute;
             Ok(data)
         })
@@ -329,10 +283,11 @@ pub fn get_protocol_info_handler() -> ActionHandler {
         Box::pin(async move {
             let mut data = data;
             set!(&mut data, "Source", String::new());
+            // Serveur-side streaming : on produit du FLAC uniquement
             set!(
                 &mut data,
                 "Sink",
-                "http-get:*:audio/mpeg:*,http-get:*:audio/mp4:*,http-get:*:audio/ogg:*,http-get:*:audio/flac:*,http-get:*:audio/wav:*,http-get:*:audio/x-flac:*,http-get:*:audio/aac:*,http-get:*:audio/webm:*".to_string()
+                "http-get:*:audio/flac:*,http-get:*:audio/x-flac:*".to_string()
             );
             Ok(data)
         })
diff --git a/pmowebrenderer/src/lib.rs b/pmowebrenderer/src/lib.rs
index 08535f07..b27f2471 100644
--- a/pmowebrenderer/src/lib.rs
+++ b/pmowebrenderer/src/lib.rs
@@ -1,25 +1,29 @@
-//! PMO Web Renderer - Transforme un navigateur en MediaRenderer UPnP privé
+//! PMO Web Renderer — Transforme un navigateur en MediaRenderer UPnP privé
+//!
+//! Architecture serveur-side streaming :
+//! - Le serveur ouvre la source audio (fichier/HTTP) et l'encode en FLAC
+//! - Le navigateur lit un flux FLAC via GET /api/webrenderer/{id}/stream
+//! - Les commandes UPnP sont relayées vers le pipeline audio via PipelineControl
 
 mod error;
 mod handlers;
 mod messages;
+mod pipeline;
+mod register;
+mod registry;
 mod renderer;
-mod session;
 mod state;
-mod websocket;
+mod stream;
 
 #[cfg(feature = "pmoserver")]
 mod config;
 
 pub use error::WebRendererError;
-pub use messages::{
-    BrowserCapabilities, ClientMessage, CommandParams, PlaybackState, RendererInfo, ServerMessage,
-    TrackMetadata, TransportAction,
-};
+pub use messages::PlaybackState;
+pub use pipeline::{PipelineControl, PipelineHandle};
+pub use registry::{RendererRegistry, WebRendererInstance};
 pub use renderer::{FactoryError, WebRendererFactory};
-pub use session::{SessionManager, WebRendererSession};
 pub use state::{RendererState, SharedState};
-pub use websocket::{websocket_handler, WebSocketState};
 
 #[cfg(feature = "pmoserver")]
 pub use config::WebRendererExt;
diff --git a/pmowebrenderer/src/pipeline.rs b/pmowebrenderer/src/pipeline.rs
new file mode 100644
index 00000000..4f8548d0
--- /dev/null
+++ b/pmowebrenderer/src/pipeline.rs
@@ -0,0 +1,448 @@
+//! Pipeline audio serveur par instance WebRenderer
+//!
+//! Chaque instance WebRenderer possède un pipeline indépendant :
+//! - Un `StreamingFlacSink` qui encode et diffuse le flux FLAC aux clients HTTP
+//! - Un canal de contrôle `PipelineControl` alimenté par les handlers UPnP
+//! - Une task background qui orchestre sources et sink
+
+use std::sync::Arc;
+
+use pmoaudio::{AudioSegment, PositionTrackerNode, ResamplingNode, ToI24Node};
+use pmometadata::{MemoryTrackMetadata, TrackMetadata};
+use pmoaudio_ext::sinks::{
+    OggFlacStreamHandle, StreamingOggFlacSink,
+    DIRECT_OGG_FLAC_BITS_PER_SAMPLE, DIRECT_OGG_FLAC_SAMPLE_RATE,
+};
+use pmoaudio_ext::UriSource;
+use pmoflac::EncoderOptions;
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+use tracing::{debug, info, warn};
+
+use crate::messages::PlaybackState;
+use crate::state::SharedState;
+
+// ─── Commandes de contrôle ───────────────────────────────────────────────────
+
+/// Commandes envoyées au pipeline audio de l'instance
+#[derive(Debug)]
+pub enum PipelineControl {
+    LoadUri(String),
+    LoadNextUri(String),
+    Play,
+    Pause,
+    Stop,
+    Seek(f64),
+    SetVolume(u16),
+    SetMute(bool),
+    /// Notification interne : la source courante s'est terminée (EOF ou erreur)
+    SourceEnded,
+}
+
+// ─── Handle vers le pipeline ─────────────────────────────────────────────────
+
+/// Handle partageable vers le pipeline audio d'une instance
+#[derive(Clone)]
+pub struct PipelineHandle {
+    pub control_tx: mpsc::Sender<PipelineControl>,
+    pub stop_token: CancellationToken,
+}
+
+impl PipelineHandle {
+    pub async fn send(&self, cmd: PipelineControl) {
+        let _ = self.control_tx.send(cmd).await;
+    }
+}
+
+// ─── Pipeline instancié ──────────────────────────────────────────────────────
+
+/// Pipeline audio complet pour une instance WebRenderer.
+///
+/// Créé au `POST /register`. Le flux OGG-FLAC est accessible via `flac_handle`
+/// (multi-clients, chaque `subscribe()` retourne un nouveau flux depuis le point courant).
+pub struct InstancePipeline {
+    /// Handle vers le sink OGG-FLAC — clonable, chaque subscribe() donne un flux live.
+    pub flac_handle: OggFlacStreamHandle,
+    pub pipeline_handle: PipelineHandle,
+}
+
+impl InstancePipeline {
+    /// Crée et démarre le pipeline en background.
+    /// Retourne immédiatement avec les handles nécessaires.
+    pub fn start(
+        state: SharedState,
+        #[cfg(feature = "pmoserver")]
+        control_point: Arc<pmocontrol::ControlPoint>,
+        udn: String,
+    ) -> Self {
+        let stop_token = CancellationToken::new();
+        let (control_tx, control_rx) = mpsc::channel::<PipelineControl>(32);
+
+        // Chaîne de traitement : ResamplingNode(96kHz) → ToI24Node → DirectFlacSink
+        // La backpressure remonte naturellement depuis le pipe duplex jusqu'à la source.
+        use pmoaudio::pipeline::AudioPipelineNode;
+
+        let (sink, flac_handle) = StreamingOggFlacSink::new(
+            EncoderOptions::default(),
+            DIRECT_OGG_FLAC_BITS_PER_SAMPLE,
+        );
+
+        // Nœud de suivi de position : lit le timestamp des chunks sortant vers le sink
+        let (mut position_tracker, position_handle) = PositionTrackerNode::new();
+        position_tracker.register(sink.boxed());
+
+        // Nœud de conversion de profondeur : tout type entier → I24
+        let mut to_i24 = ToI24Node::new();
+        to_i24.register(position_tracker.boxed());
+
+        // Nœud de rééchantillonnage : n'importe quel sample rate → 96 kHz
+        let mut resampler = ResamplingNode::new(DIRECT_OGG_FLAC_SAMPLE_RATE);
+        resampler.register(to_i24.boxed());
+
+        // Le tx d'entrée du resampler est le point d'entrée du pipeline
+        let segment_tx = resampler.get_tx().expect("ResamplingNode doit avoir un sender");
+
+        let pipeline_handle = PipelineHandle {
+            control_tx,
+            stop_token: stop_token.clone(),
+        };
+
+        // Lancer la chaîne resampler → to_i24 → sink en background
+        let sink_stop = stop_token.clone();
+        tokio::spawn(async move {
+            if let Err(e) = resampler.boxed().run(sink_stop).await {
+                warn!("Audio pipeline error: {:?}", e);
+            }
+            debug!("Sink task terminated");
+        });
+
+        // Task de mise à jour de la position (toutes les secondes)
+        {
+            let state_pos = state.clone();
+            let pos_stop = stop_token.clone();
+            tokio::spawn(async move {
+                loop {
+                    tokio::select! {
+                        _ = pos_stop.cancelled() => break,
+                        _ = tokio::time::sleep(std::time::Duration::from_secs(1)) => {
+                            let pos = position_handle.current_position_sec();
+                            if pos > 0.0 {
+                                state_pos.write().position = Some(seconds_to_upnp_time(pos));
+                            }
+                        }
+                    }
+                }
+            });
+        }
+
+        // Task pipeline : reçoit les commandes UPnP et pilote les sources
+        let stop_token_clone = stop_token.clone();
+        let control_tx_clone = pipeline_handle.control_tx.clone();
+        tokio::spawn(async move {
+            run_pipeline(
+                segment_tx,
+                control_rx,
+                control_tx_clone,
+                stop_token_clone,
+                state,
+                udn,
+                #[cfg(feature = "pmoserver")]
+                control_point,
+            )
+            .await;
+            debug!("Pipeline task terminated");
+        });
+
+        Self {
+            flac_handle,
+            pipeline_handle,
+        }
+    }
+}
+
+// ─── Task principale du pipeline ─────────────────────────────────────────────
+
+async fn run_pipeline(
+    segment_tx: mpsc::Sender<Arc<AudioSegment>>,
+    mut control_rx: mpsc::Receiver<PipelineControl>,
+    control_tx: mpsc::Sender<PipelineControl>,
+    stop_token: CancellationToken,
+    state: SharedState,
+    udn: String,
+    #[cfg(feature = "pmoserver")]
+    control_point: Arc<pmocontrol::ControlPoint>,
+) {
+    let mut current_source_stop: Option<CancellationToken> = None;
+    let mut current_uri: Option<String> = None;
+
+    loop {
+        tokio::select! {
+            _ = stop_token.cancelled() => {
+                info!(udn = %udn, "Pipeline stopping by cancellation");
+                if let Some(src_stop) = current_source_stop.take() {
+                    src_stop.cancel();
+                }
+                break;
+            }
+
+            cmd = control_rx.recv() => {
+                match cmd {
+                    None => {
+                        info!(udn = %udn, "Pipeline control channel closed");
+                        break;
+                    }
+
+                    Some(PipelineControl::SourceEnded) => {
+                        // La source s'est terminée (EOF ou erreur) : libérer le slot
+                        debug!(udn = %udn, "Pipeline: SourceEnded — source slot freed");
+                        current_source_stop = None;
+                    }
+
+                    Some(PipelineControl::LoadUri(uri)) => {
+                        info!(udn = %udn, uri = %uri, "Pipeline: LoadUri");
+                        if let Some(src_stop) = current_source_stop.take() {
+                            src_stop.cancel();
+                        }
+                        current_uri = Some(uri.clone());
+                        {
+                            let mut s = state.write();
+                            s.playback_state = PlaybackState::Transitioning;
+                            s.current_uri = Some(uri.clone());
+                            s.position = None;
+                        }
+                        let src_stop = stop_token.child_token();
+                        current_source_stop = Some(src_stop.clone());
+                        let tx = segment_tx.clone();
+                        let notify = control_tx.clone();
+                        let st = state.clone();
+                        let udn_c = udn.clone();
+                        #[cfg(feature = "pmoserver")]
+                        let cp = control_point.clone();
+                        tokio::spawn(async move {
+                            stream_source(
+                                uri, 0.0, tx, src_stop, st, udn_c,
+                                #[cfg(feature = "pmoserver")]
+                                cp,
+                            ).await;
+                            let _ = notify.send(PipelineControl::SourceEnded).await;
+                        });
+                    }
+
+                    Some(PipelineControl::LoadNextUri(uri)) => {
+                        debug!(udn = %udn, uri = %uri, "Pipeline: LoadNextUri");
+                        state.write().next_uri = Some(uri);
+                    }
+
+                    Some(PipelineControl::Play) => {
+                        // Redémarrer la source si elle n'est pas en cours
+                        if current_source_stop.is_none() {
+                            if let Some(uri) = current_uri.clone() {
+                                info!(udn = %udn, uri = %uri, "Pipeline: Play — restarting source");
+                                let src_stop = stop_token.child_token();
+                                current_source_stop = Some(src_stop.clone());
+                                let tx = segment_tx.clone();
+                                let notify = control_tx.clone();
+                                let st = state.clone();
+                                let udn_c = udn.clone();
+                                #[cfg(feature = "pmoserver")]
+                                let cp = control_point.clone();
+                                tokio::spawn(async move {
+                                    stream_source(
+                                        uri, 0.0, tx, src_stop, st, udn_c,
+                                        #[cfg(feature = "pmoserver")]
+                                        cp,
+                                    ).await;
+                                    let _ = notify.send(PipelineControl::SourceEnded).await;
+                                });
+                            } else {
+                                debug!(udn = %udn, "Pipeline: Play — no URI loaded, ignoring");
+                            }
+                        } else {
+                            debug!(udn = %udn, "Pipeline: Play — source already running");
+                        }
+                    }
+
+                    Some(PipelineControl::Pause) => {
+                        debug!(udn = %udn, "Pipeline: Pause (not supported on live stream)");
+                    }
+
+                    Some(PipelineControl::Stop) => {
+                        info!(udn = %udn, "Pipeline: Stop");
+                        if let Some(src_stop) = current_source_stop.take() {
+                            src_stop.cancel();
+                        }
+                        // Conserver current_uri pour permettre un Play ultérieur
+                        let mut s = state.write();
+                        s.playback_state = PlaybackState::Stopped;
+                        s.position = None;
+                    }
+
+                    Some(PipelineControl::Seek(pos_sec)) => {
+                        info!(udn = %udn, pos = pos_sec, "Pipeline: Seek");
+                        if let Some(uri) = current_uri.clone() {
+                            if let Some(src_stop) = current_source_stop.take() {
+                                src_stop.cancel();
+                            }
+                            let src_stop = stop_token.child_token();
+                            current_source_stop = Some(src_stop.clone());
+                            let tx = segment_tx.clone();
+                            let notify = control_tx.clone();
+                            let st = state.clone();
+                            let udn_c = udn.clone();
+                            #[cfg(feature = "pmoserver")]
+                            let cp = control_point.clone();
+                            tokio::spawn(async move {
+                                stream_source(
+                                    uri, pos_sec, tx, src_stop, st, udn_c,
+                                    #[cfg(feature = "pmoserver")]
+                                    cp,
+                                ).await;
+                                let _ = notify.send(PipelineControl::SourceEnded).await;
+                            });
+                        }
+                    }
+
+                    Some(PipelineControl::SetVolume(vol)) => {
+                        state.write().volume = vol;
+                    }
+
+                    Some(PipelineControl::SetMute(mute)) => {
+                        state.write().mute = mute;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ─── Task source ─────────────────────────────────────────────────────────────
+
+async fn stream_source(
+    uri: String,
+    seek_sec: f64,
+    tx: mpsc::Sender<Arc<AudioSegment>>,
+    stop_token: CancellationToken,
+    state: SharedState,
+    udn: String,
+    #[cfg(feature = "pmoserver")]
+    control_point: Arc<pmocontrol::ControlPoint>,
+) {
+    info!(udn = %udn, uri = %uri, seek = seek_sec, "Source task: opening URI");
+
+    match UriSource::open(&uri, seek_sec, stop_token.clone()).await {
+        Ok(source) => {
+            debug!(udn = %udn, "Source task: URI opened, duration={:?}", source.duration_sec());
+            if let Some(dur) = source.duration_sec() {
+                state.write().duration = Some(seconds_to_upnp_time(dur));
+            }
+
+            // TrackBoundary avec métadonnées minimales
+            let boundary = {
+                let mut meta = MemoryTrackMetadata::new();
+                let _ = meta.set_title(Some(uri.clone())).await;
+                let meta_arc = Arc::new(tokio::sync::RwLock::new(meta));
+                AudioSegment::new_track_boundary(0, seek_sec, meta_arc)
+            };
+            let _ = tx.send(boundary).await;
+
+            // L'URI est ouverte, le flux va commencer à couler.
+            // Le sink bloquera naturellement si aucun client HTTP n'est connecté.
+            {
+                let mut s = state.write();
+                s.playback_state = PlaybackState::Playing;
+                if seek_sec > 0.0 {
+                    s.position = Some(seconds_to_upnp_time(seek_sec));
+                }
+            }
+
+            match source.emit_to_channel(&tx, &stop_token).await {
+                Ok(true) => {
+                    debug!(udn = %udn, "Source task: EOF → TrackEnded");
+                    handle_track_ended(
+                        state, udn, tx, stop_token,
+                        #[cfg(feature = "pmoserver")]
+                        control_point,
+                    ).await;
+                }
+                Ok(false) => {
+                    debug!(udn = %udn, "Source task: cancelled");
+                }
+                Err(e) => {
+                    warn!(udn = %udn, error = %e, "Source task error");
+                    state.write().playback_state = PlaybackState::Stopped;
+                }
+            }
+        }
+        Err(e) => {
+            warn!(udn = %udn, error = %e, "Source task: failed to open URI");
+            state.write().playback_state = PlaybackState::Stopped;
+        }
+    }
+}
+
+// ─── TrackEnded : avancer current←next ───────────────────────────────────────
+
+async fn handle_track_ended(
+    state: SharedState,
+    udn: String,
+    tx: mpsc::Sender<Arc<AudioSegment>>,
+    stop_token: CancellationToken,
+    #[cfg(feature = "pmoserver")]
+    control_point: Arc<pmocontrol::ControlPoint>,
+) {
+    let next_uri = {
+        let mut s = state.write();
+        let uri = s.next_uri.take();
+        let meta = s.next_metadata.take();
+        s.current_uri = uri.clone();
+        s.current_metadata = meta;
+        s.next_uri = None;
+        s.next_metadata = None;
+        s.position = None;
+        s.duration = None;
+        if uri.is_some() {
+            s.playback_state = PlaybackState::Playing;
+        } else {
+            s.playback_state = PlaybackState::Stopped;
+        }
+        uri
+    };
+
+    #[cfg(feature = "pmoserver")]
+    if next_uri.is_some() {
+        let cp = control_point.clone();
+        let udn_clone = udn.clone();
+        tokio::spawn(async move {
+            cp.advance_queue_and_prefetch(&pmocontrol::DeviceId(udn_clone));
+        });
+    }
+
+    if let Some(uri) = next_uri {
+        info!(udn = %udn, uri = %uri, "TrackEnded: starting next track");
+        Box::pin(stream_source(
+            uri, 0.0, tx, stop_token, state, udn,
+            #[cfg(feature = "pmoserver")]
+            control_point,
+        )).await;
+    }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+pub fn seconds_to_upnp_time(s: f64) -> String {
+    let s = s as u64;
+    let h = s / 3600;
+    let m = (s % 3600) / 60;
+    let sec = s % 60;
+    format!("{}:{:02}:{:02}", h, m, sec)
+}
+
+pub fn upnp_time_to_seconds(t: &str) -> f64 {
+    let parts: Vec<f64> = t.split(':').filter_map(|p| p.parse().ok()).collect();
+    match parts.as_slice() {
+        [h, m, s] => h * 3600.0 + m * 60.0 + s,
+        [m, s] => m * 60.0 + s,
+        [s] => *s,
+        _ => 0.0,
+    }
+}
diff --git a/pmowebrenderer/src/register.rs b/pmowebrenderer/src/register.rs
new file mode 100644
index 00000000..a78ef396
--- /dev/null
+++ b/pmowebrenderer/src/register.rs
@@ -0,0 +1,72 @@
+//! Handlers HTTP pour l'enregistrement/désenregistrement des instances WebRenderer.
+//!
+//! - POST /api/webrenderer/register  → crée ou reconnecte une instance
+//! - DELETE /api/webrenderer/{id}    → désenregistrement explicite
+
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+    Json,
+};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+use crate::registry::RendererRegistry;
+
+#[derive(Debug, Deserialize)]
+pub struct RegisterRequest {
+    pub instance_id: String,
+    pub user_agent: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct RegisterResponse {
+    pub stream_url: String,
+    pub udn: String,
+}
+
+/// POST /api/webrenderer/register
+pub async fn register_handler(
+    State(registry): State<Arc<RendererRegistry>>,
+    Json(req): Json<RegisterRequest>,
+) -> impl IntoResponse {
+    tracing::info!(
+        instance_id = %req.instance_id,
+        user_agent = %req.user_agent,
+        "WebRenderer: register request"
+    );
+
+    match registry
+        .register_or_reconnect(&req.instance_id, &req.user_agent)
+        .await
+    {
+        Ok((stream_url, udn)) => {
+            tracing::info!(
+                instance_id = %req.instance_id,
+                stream_url = %stream_url,
+                udn = %udn,
+                "WebRenderer: registered"
+            );
+            (StatusCode::OK, Json(RegisterResponse { stream_url, udn })).into_response()
+        }
+        Err(e) => {
+            tracing::error!(
+                instance_id = %req.instance_id,
+                error = %e,
+                "WebRenderer: registration failed"
+            );
+            (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response()
+        }
+    }
+}
+
+/// DELETE /api/webrenderer/{id}
+pub async fn unregister_handler(
+    State(registry): State<Arc<RendererRegistry>>,
+    Path(instance_id): Path<String>,
+) -> impl IntoResponse {
+    tracing::info!(instance_id = %instance_id, "WebRenderer: explicit unregister");
+    registry.schedule_unregister(&instance_id);
+    StatusCode::NO_CONTENT
+}
diff --git a/pmowebrenderer/src/registry.rs b/pmowebrenderer/src/registry.rs
new file mode 100644
index 00000000..b49e2c06
--- /dev/null
+++ b/pmowebrenderer/src/registry.rs
@@ -0,0 +1,346 @@
+//! Registre des instances WebRenderer actives.
+//!
+//! Remplace `SessionManager` et `websocket.rs`. La session est maintenant liée
+//! au flux FLAC HTTP, pas à une connexion WebSocket.
+
+use parking_lot::RwLock;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::SystemTime;
+
+use pmoupnp::devices::DeviceInstance;
+
+use crate::error::WebRendererError;
+use crate::pipeline::{InstancePipeline, PipelineHandle};
+use crate::renderer::WebRendererFactory;
+use crate::state::{RendererState, SharedState};
+use crate::messages::PlaybackState;
+
+#[cfg(feature = "pmoserver")]
+use pmocontrol::{ControlPoint, DeviceId};
+#[cfg(feature = "pmoserver")]
+use pmocontrol::model::{RendererCapabilities, RendererProtocol};
+#[cfg(feature = "pmoserver")]
+use pmoupnp::UpnpTypedInstance;
+
+/// Une instance WebRenderer côté serveur
+pub struct WebRendererInstance {
+    pub instance_id: String,
+    pub udn: String,
+    pub device_instance: Arc<DeviceInstance>,
+    pub state: SharedState,
+    /// Handle vers le sink OGG-FLAC — clonable, chaque subscribe() donne un flux live.
+    pub flac_handle: pmoaudio_ext::sinks::OggFlacStreamHandle,
+    pub pipeline: PipelineHandle,
+    pub created_at: SystemTime,
+}
+
+/// Registre global des instances WebRenderer
+pub struct RendererRegistry {
+    /// Map instance_id → instance
+    instances: RwLock<HashMap<String, Arc<WebRendererInstance>>>,
+    /// Map udn → instance (pour retrouver depuis les handlers UPnP)
+    by_udn: RwLock<HashMap<String, Arc<WebRendererInstance>>>,
+    /// Tokens d'annulation des unregister différés (instance_id → token)
+    pending_unregister: RwLock<HashMap<String, tokio_util::sync::CancellationToken>>,
+    #[cfg(feature = "pmoserver")]
+    control_point: Arc<ControlPoint>,
+}
+
+impl RendererRegistry {
+    #[cfg(feature = "pmoserver")]
+    pub fn new(control_point: Arc<ControlPoint>) -> Self {
+        Self {
+            instances: RwLock::new(HashMap::new()),
+            by_udn: RwLock::new(HashMap::new()),
+            pending_unregister: RwLock::new(HashMap::new()),
+            control_point,
+        }
+    }
+
+    #[cfg(not(feature = "pmoserver"))]
+    pub fn new() -> Self {
+        Self {
+            instances: RwLock::new(HashMap::new()),
+            by_udn: RwLock::new(HashMap::new()),
+            pending_unregister: RwLock::new(HashMap::new()),
+        }
+    }
+
+    /// Enregistre ou reconnecte une instance.
+    /// Retourne `(stream_url, udn)`.
+    pub async fn register_or_reconnect(
+        &self,
+        instance_id: &str,
+        user_agent: &str,
+    ) -> Result<(String, String), WebRendererError> {
+        // Annuler tout unregister différé pour cet instance_id
+        if let Some(cancel) = self.pending_unregister.write().remove(instance_id) {
+            tracing::info!(instance_id = %instance_id, "WebRenderer: cancelled pending unregister (page reload)");
+            cancel.cancel();
+        }
+
+        // Reconnexion : l'instance existe déjà (ou vient d'être conservée)
+        {
+            let instances = self.instances.read();
+            if let Some(existing) = instances.get(instance_id) {
+                tracing::info!(instance_id = %instance_id, "WebRenderer: reconnecting existing instance");
+                #[cfg(feature = "pmoserver")]
+                self.register_with_control_point(&existing.device_instance)?;
+                let stream_url = format!("/api/webrenderer/{}/stream", instance_id);
+                return Ok((stream_url, existing.udn.clone()));
+            }
+        }
+
+        // Première connexion : créer device UPnP + pipeline
+        let instance = self.create_instance(instance_id, user_agent).await?;
+        let instance = Arc::new(instance);
+        let stream_url = format!("/api/webrenderer/{}/stream", instance_id);
+        let udn = instance.udn.clone();
+
+        {
+            let mut instances = self.instances.write();
+            instances.insert(instance_id.to_string(), instance.clone());
+        }
+        {
+            let mut by_udn = self.by_udn.write();
+            by_udn.insert(instance.udn.clone(), instance.clone());
+        }
+
+        tracing::info!(
+            instance_id = %instance_id,
+            udn = %udn,
+            "WebRenderer: new instance registered"
+        );
+
+        Ok((stream_url, udn))
+    }
+
+    /// Retourne le OggFlacStreamHandle pour l'endpoint /stream (clonable).
+    pub fn get_flac_handle(
+        &self,
+        instance_id: &str,
+    ) -> Option<pmoaudio_ext::sinks::OggFlacStreamHandle> {
+        self.instances
+            .read()
+            .get(instance_id)
+            .map(|i| i.flac_handle.clone())
+    }
+
+    /// Retourne le PipelineHandle par UDN (pour les handlers UPnP)
+    pub fn get_pipeline_by_udn(&self, udn: &str) -> Option<PipelineHandle> {
+        self.by_udn
+            .read()
+            .get(udn)
+            .map(|i| i.pipeline.clone())
+    }
+
+    /// Retourne le SharedState par UDN
+    pub fn get_state_by_udn(&self, udn: &str) -> Option<SharedState> {
+        self.by_udn
+            .read()
+            .get(udn)
+            .map(|i| i.state.clone())
+    }
+
+    /// Retourne le DeviceInstance par UDN
+    pub fn get_device_by_udn(&self, udn: &str) -> Option<Arc<DeviceInstance>> {
+        self.by_udn
+            .read()
+            .get(udn)
+            .map(|i| i.device_instance.clone())
+    }
+
+    pub fn schedule_unregister(self: &Arc<Self>, instance_id: &str) {
+        use tokio_util::sync::CancellationToken;
+
+        // Ne pas détruire immédiatement : attendre 5s au cas où la page se recharge
+        let cancel = CancellationToken::new();
+        self.pending_unregister.write().insert(instance_id.to_string(), cancel.clone());
+
+        let instance_id_owned = instance_id.to_string();
+        let registry = Arc::clone(self);
+
+        tracing::info!(instance_id = %instance_id, "WebRenderer: unregister scheduled (5s grace period)");
+
+        tokio::spawn(async move {
+            tokio::select! {
+                _ = cancel.cancelled() => {
+                    tracing::info!(instance_id = %instance_id_owned, "WebRenderer: deferred unregister cancelled (page reload)");
+                }
+                _ = tokio::time::sleep(std::time::Duration::from_secs(5)) => {
+                    registry.pending_unregister.write().remove(&instance_id_owned);
+                    let instance = registry.instances.write().remove(&instance_id_owned);
+                    if let Some(instance) = instance {
+                        registry.by_udn.write().remove(&instance.udn);
+                        instance.pipeline.stop_token.cancel();
+                        #[cfg(feature = "pmoserver")]
+                        if let Ok(mut reg) = registry.control_point.registry().write() {
+                            reg.device_says_byebye(&instance.udn);
+                        }
+                        tracing::info!(
+                            instance_id = %instance_id_owned,
+                            udn = %instance.udn,
+                            "WebRenderer: instance unregistered"
+                        );
+                    }
+                }
+            }
+        });
+    }
+
+    // ── Création d'instance ────────────────────────────────────────────────────
+
+    async fn create_instance(
+        &self,
+        instance_id: &str,
+        user_agent: &str,
+    ) -> Result<WebRendererInstance, WebRendererError> {
+        // UDN stable dérivé de l'instance_id
+        let candidate_udn = instance_id.to_ascii_lowercase();
+        let full_udn = format!("uuid:{}", candidate_udn);
+
+        // Persister l'UDN dans la config (pour que device_instance.rs le retrouve)
+        if let Err(e) = pmoconfig::get_config().set_device_udn(
+            "MediaRenderer",
+            instance_id,
+            candidate_udn.clone(),
+        ) {
+            tracing::warn!("WebRenderer: failed to persist UDN: {:?}", e);
+        }
+
+        let state: SharedState = Arc::new(parking_lot::RwLock::new(RendererState::default()));
+
+        #[cfg(feature = "pmoserver")]
+        let (device_instance, pipeline) = {
+            use pmoupnp::UpnpServerExt;
+
+            let server_arc = pmoserver::get_server()
+                .ok_or(WebRendererError::ServerNotAvailable)?;
+
+            // Créer le pipeline d'abord pour avoir le PipelineHandle
+            let ip = InstancePipeline::start(
+                state.clone(),
+                self.control_point.clone(),
+                full_udn.clone(),
+            );
+            let pipeline = ip.pipeline_handle.clone();
+
+            // Vérifier si un device avec ce même UDN existe déjà
+            let existing_di = {
+                let server = server_arc.read().await;
+                server.get_device(&candidate_udn)
+            };
+
+            let di = if let Some(di) = existing_di {
+                tracing::info!(udn = %candidate_udn, "WebRenderer: reusing device from registry");
+                di
+            } else {
+                // Créer le device UPnP
+                tracing::info!(udn = %candidate_udn, "WebRenderer: creating new device");
+                let device = WebRendererFactory::create_device_with_pipeline(
+                    instance_id,
+                    user_agent,
+                    pipeline.clone(),
+                    state.clone(),
+                )
+                .map_err(|e| WebRendererError::DeviceCreationError(e.to_string()))?;
+
+                let mut server = server_arc.write().await;
+                server
+                    .register_device(Arc::new(device))
+                    .await
+                    .map_err(|e| WebRendererError::RegistrationError(e.to_string()))?
+            };
+
+            self.register_with_control_point(&di)?;
+            (di, ip)
+        };
+
+        #[cfg(not(feature = "pmoserver"))]
+        let (device_instance, pipeline) = {
+            use pmoupnp::UpnpModel;
+
+            let ip = InstancePipeline::start(state.clone(), full_udn.clone());
+            let pipeline = ip.pipeline_handle.clone();
+
+            let device = WebRendererFactory::create_device_with_pipeline(
+                instance_id,
+                user_agent,
+                pipeline.clone(),
+                state.clone(),
+            )
+            .map_err(|e| WebRendererError::DeviceCreationError(e.to_string()))?;
+
+            (Arc::new(device).create_instance(), ip)
+        };
+
+        Ok(WebRendererInstance {
+            instance_id: instance_id.to_string(),
+            udn: full_udn,
+            device_instance,
+            state,
+            flac_handle: pipeline.flac_handle.clone(),
+            pipeline: pipeline.pipeline_handle,
+            created_at: SystemTime::now(),
+        })
+    }
+
+    /// Enregistre le device dans le ControlPoint
+    #[cfg(feature = "pmoserver")]
+    fn register_with_control_point(
+        &self,
+        di: &Arc<DeviceInstance>,
+    ) -> Result<(), WebRendererError> {
+        let base_url = di.base_url().to_string();
+        let udn = di.udn().to_ascii_lowercase();
+        let udn_with_prefix = format!("uuid:{}", udn);
+        let device_route = di.route();
+        let model = di.get_model();
+
+        let avtransport_control_url = Some(format!(
+            "{}{}/service/AVTransport/control",
+            base_url, device_route
+        ));
+        let rendering_control_url = Some(format!(
+            "{}{}/service/RenderingControl/control",
+            base_url, device_route
+        ));
+        let connection_manager_url = Some(format!(
+            "{}{}/service/ConnectionManager/control",
+            base_url, device_route
+        ));
+
+        let renderer_info = pmocontrol::RendererInfo::make(
+            DeviceId(udn_with_prefix.clone()),
+            udn_with_prefix.clone(),
+            model.friendly_name().to_string(),
+            model.model_name().to_string(),
+            "PMOMusic".to_string(),
+            RendererProtocol::UpnpAvOnly,
+            RendererCapabilities {
+                has_avtransport: true,
+                has_avtransport_set_next: true,
+                has_rendering_control: true,
+                has_connection_manager: true,
+                ..Default::default()
+            },
+            format!("{}{}", base_url, di.description_route()),
+            "PMOMusic WebRenderer/2.0".to_string(),
+            Some("urn:schemas-upnp-org:service:AVTransport:1".to_string()),
+            avtransport_control_url,
+            Some("urn:schemas-upnp-org:service:RenderingControl:1".to_string()),
+            rendering_control_url,
+            Some("urn:schemas-upnp-org:service:ConnectionManager:1".to_string()),
+            connection_manager_url,
+            None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
+        );
+
+        if let Ok(mut registry) = self.control_point.registry().write() {
+            registry.push_renderer(&renderer_info, 86400);
+        }
+
+        tracing::info!(udn = %udn, "WebRenderer: registered with ControlPoint");
+        Ok(())
+    }
+}
diff --git a/pmowebrenderer/src/renderer.rs b/pmowebrenderer/src/renderer.rs
index dd2e7a42..ad0b77f5 100644
--- a/pmowebrenderer/src/renderer.rs
+++ b/pmowebrenderer/src/renderer.rs
@@ -5,15 +5,13 @@
 
 use std::sync::Arc;
 use thiserror::Error;
-use tokio::sync::mpsc;
-
 use pmoupnp::actions::{Action, Argument};
 use pmoupnp::devices::Device;
 use pmoupnp::services::Service;
 
 use crate::handlers;
-use crate::messages::ServerMessage;
-use crate::state::{SharedSender, SharedState};
+use crate::pipeline::PipelineHandle;
+use crate::state::SharedState;
 
 // ─── Réimport des variables statiques de pmomediarenderer ───────────────────
 // Variables AVTransport
@@ -65,7 +63,7 @@ fn extract_browser_name(ua: &str) -> &str {
     }
 }
 
-/// Factory pour créer des Device UPnP WebRenderer avec des handlers WebSocket
+/// Factory pour créer des Device UPnP WebRenderer avec un pipeline audio serveur
 pub struct WebRendererFactory;
 
 impl WebRendererFactory {
@@ -73,26 +71,23 @@ impl WebRendererFactory {
     ///
     /// `device_name` sert de clé pour retrouver l'UDN persistant dans la config.
     /// `browser_ua` est le User-Agent complet (pour déterminer le nom affiché).
-    ///
-    /// Retourne le Device et le `SharedSender` associé. Le `SharedSender` peut être
-    /// mis à jour à chaque reconnexion WebSocket via `shared_sender.set(new_tx)`.
-    pub fn create_device_with_name(
+    pub fn create_device_with_pipeline(
         device_name: &str,
         browser_ua: &str,
-        ws_sender: mpsc::UnboundedSender<ServerMessage>,
+        pipeline: PipelineHandle,
         state: SharedState,
-    ) -> Result<(Device, SharedSender), FactoryError> {
-        let shared_sender = SharedSender::new(ws_sender);
-        let avtransport = Self::build_avtransport(shared_sender.clone(), state.clone())?;
-        let renderingcontrol = Self::build_renderingcontrol(shared_sender.clone(), state.clone())?;
+    ) -> Result<Device, FactoryError> {
+        let avtransport = Self::build_avtransport(pipeline.clone(), state.clone())?;
+        let renderingcontrol = Self::build_renderingcontrol(pipeline.clone(), state.clone())?;
         let connectionmanager = Self::build_connectionmanager()?;
 
         let short_name = extract_browser_name(browser_ua);
-        let device = Device::new(
+        let mut device = Device::new(
             device_name.to_string(),
             "MediaRenderer".to_string(),
             format!("Web Audio – {}", short_name),
         );
+        device.set_model_name("WebRenderer".to_string());
         device
             .add_service(Arc::new(avtransport))
             .map_err(|e| FactoryError::ServiceError(format!("{:?}", e)))?;
@@ -103,12 +98,12 @@ impl WebRendererFactory {
             .add_service(Arc::new(connectionmanager))
             .map_err(|e| FactoryError::ServiceError(format!("{:?}", e)))?;
 
-        Ok((device, shared_sender))
+        Ok(device)
     }
 
-    /// Construit le service AVTransport avec les handlers WebSocket
+    /// Construit le service AVTransport avec les handlers pipeline
     fn build_avtransport(
-        ws: SharedSender,
+        pipeline: PipelineHandle,
         state: SharedState,
     ) -> Result<Service, FactoryError> {
         let mut svc = Service::new("AVTransport".to_string());
@@ -158,7 +153,7 @@ impl WebRendererFactory {
             Arc::clone(&TRANSPORTPLAYSPEED),
         )))
         .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        play.set_handler(handlers::play_handler(ws.clone(), state.clone()));
+        play.set_handler(handlers::play_handler(pipeline.clone(), state.clone()));
         add_action(&mut svc, Arc::new(play))?;
 
         // Stop
@@ -168,7 +163,7 @@ impl WebRendererFactory {
             Arc::clone(&AVT_INSTANCE_ID),
         )))
         .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        stop.set_handler(handlers::stop_handler(ws.clone(), state.clone()));
+        stop.set_handler(handlers::stop_handler(pipeline.clone(), state.clone()));
         add_action(&mut svc, Arc::new(stop))?;
 
         // Pause
@@ -179,7 +174,7 @@ impl WebRendererFactory {
                 Arc::clone(&AVT_INSTANCE_ID),
             )))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        pause.set_handler(handlers::pause_handler(ws.clone(), state.clone()));
+        pause.set_handler(handlers::pause_handler(pipeline.clone(), state.clone()));
         add_action(&mut svc, Arc::new(pause))?;
 
         // Next
@@ -189,7 +184,7 @@ impl WebRendererFactory {
             Arc::clone(&AVT_INSTANCE_ID),
         )))
         .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        next.set_handler(handlers::next_handler(ws.clone()));
+        next.set_handler(handlers::next_handler(pipeline.clone()));
         add_action(&mut svc, Arc::new(next))?;
 
         // Previous
@@ -200,7 +195,7 @@ impl WebRendererFactory {
                 Arc::clone(&AVT_INSTANCE_ID),
             )))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        previous.set_handler(handlers::previous_handler(ws.clone()));
+        previous.set_handler(handlers::previous_handler(pipeline.clone()));
         add_action(&mut svc, Arc::new(previous))?;
 
         // Seek
@@ -220,7 +215,7 @@ impl WebRendererFactory {
             Arc::clone(&SEEKMODE),
         )))
         .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        seek.set_handler(handlers::seek_handler(ws.clone()));
+        seek.set_handler(handlers::seek_handler(pipeline.clone()));
         add_action(&mut svc, Arc::new(seek))?;
 
         // SetAVTransportURI
@@ -243,7 +238,7 @@ impl WebRendererFactory {
                 Arc::clone(&AVTRANSPORTURIMETADATA),
             )))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        set_uri.set_handler(handlers::set_uri_handler(ws.clone(), state.clone()));
+        set_uri.set_handler(handlers::set_uri_handler(pipeline.clone(), state.clone()));
         add_action(&mut svc, Arc::new(set_uri))?;
 
         // SetNextAVTransportURI
@@ -266,7 +261,7 @@ impl WebRendererFactory {
                 Arc::clone(&AVTRANSPORTNEXTURIMETADATA),
             )))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        set_next_uri.set_handler(handlers::set_next_uri_handler(ws.clone(), state.clone()));
+        set_next_uri.set_handler(handlers::set_next_uri_handler(pipeline.clone(), state.clone()));
         add_action(&mut svc, Arc::new(set_next_uri))?;
 
         // GetPositionInfo
@@ -422,9 +417,9 @@ impl WebRendererFactory {
         Ok(svc)
     }
 
-    /// Construit le service RenderingControl avec les handlers WebSocket
+    /// Construit le service RenderingControl avec les handlers pipeline
     fn build_renderingcontrol(
-        ws: SharedSender,
+        pipeline: PipelineHandle,
         state: SharedState,
     ) -> Result<Service, FactoryError> {
         let mut svc = Service::new("RenderingControl".to_string());
@@ -458,7 +453,7 @@ impl WebRendererFactory {
                 Arc::clone(&VOLUME),
             )))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        set_vol.set_handler(handlers::set_volume_handler(ws.clone(), state.clone()));
+        set_vol.set_handler(handlers::set_volume_handler(pipeline.clone(), state.clone()));
         svc.add_action(Arc::new(set_vol))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
 
@@ -507,7 +502,7 @@ impl WebRendererFactory {
                 Arc::clone(&MUTE),
             )))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
-        set_mute.set_handler(handlers::set_mute_handler(ws.clone(), state.clone()));
+        set_mute.set_handler(handlers::set_mute_handler(pipeline.clone(), state.clone()));
         svc.add_action(Arc::new(set_mute))
             .map_err(|e| FactoryError::ActionError(format!("{:?}", e)))?;
 
diff --git a/pmowebrenderer/src/session.rs b/pmowebrenderer/src/session.rs
deleted file mode 100644
index 5dae2d21..00000000
--- a/pmowebrenderer/src/session.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//! Gestionnaire de sessions WebRenderer
-
-use parking_lot::RwLock;
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::{Duration, SystemTime};
-
-use pmoupnp::devices::DeviceInstance;
-
-use crate::state::{SharedSender, SharedState};
-
-/// Session WebSocket liée à un MediaRenderer privé
-pub struct WebRendererSession {
-    pub token: String,
-    pub udn: String,
-    pub device_instance: Arc<DeviceInstance>,
-    /// Sender partagé : mis à jour à chaque reconnexion WebSocket.
-    pub shared_sender: SharedSender,
-    pub state: SharedState,
-    pub created_at: SystemTime,
-    pub last_activity: Arc<RwLock<SystemTime>>,
-}
-
-/// Gestionnaire global des sessions
-#[derive(Clone)]
-pub struct SessionManager {
-    sessions: Arc<RwLock<HashMap<String, Arc<WebRendererSession>>>>,
-    /// Map UDN → SharedSender, persiste même après suppression de la session.
-    /// Permet de retrouver et mettre à jour le sender à la reconnexion.
-    senders: Arc<RwLock<HashMap<String, SharedSender>>>,
-    /// Map UDN → SharedState, persiste même après suppression de la session.
-    /// Permet de réutiliser l'état partagé avec les handlers du device existant.
-    states: Arc<RwLock<HashMap<String, SharedState>>>,
-    timeout_duration: Duration,
-}
-
-impl SessionManager {
-    pub fn new(timeout_duration: Duration) -> Self {
-        let manager = Self {
-            sessions: Arc::new(RwLock::new(HashMap::new())),
-            senders: Arc::new(RwLock::new(HashMap::new())),
-            states: Arc::new(RwLock::new(HashMap::new())),
-            timeout_duration,
-        };
-
-        manager.spawn_cleanup_task();
-        manager
-    }
-
-    pub fn add_session(&self, session: Arc<WebRendererSession>) {
-        let token = session.token.clone();
-        let udn = session.udn.clone();
-        let sender = session.shared_sender.clone();
-        let state = session.state.clone();
-        self.sessions.write().insert(token.clone(), session);
-        self.senders.write().insert(udn.clone(), sender);
-        self.states.write().insert(udn, state);
-        tracing::info!(token = %token, "WebRenderer session added");
-    }
-
-    pub fn get_session(&self, token: &str) -> Option<Arc<WebRendererSession>> {
-        let sessions = self.sessions.read();
-        if let Some(session) = sessions.get(token) {
-            *session.last_activity.write() = SystemTime::now();
-            Some(session.clone())
-        } else {
-            None
-        }
-    }
-
-    /// Retrouve une session par UDN du device (indépendant du token WebSocket).
-    pub fn get_session_by_udn(&self, udn: &str) -> Option<Arc<WebRendererSession>> {
-        let sessions = self.sessions.read();
-        sessions.values().find(|s| s.udn == udn).cloned()
-    }
-
-    /// Retrouve le SharedSender par UDN (persiste même après suppression de session).
-    pub fn get_sender_by_udn(&self, udn: &str) -> Option<SharedSender> {
-        self.senders.read().get(udn).cloned()
-    }
-
-    /// Retrouve le SharedState par UDN (persiste même après suppression de session).
-    pub fn get_state_by_udn(&self, udn: &str) -> Option<SharedState> {
-        self.states.read().get(udn).cloned()
-    }
-
-    pub fn remove_session(&self, token: &str) -> Option<Arc<WebRendererSession>> {
-        let session = self.sessions.write().remove(token);
-        if let Some(ref s) = session {
-            tracing::info!(token = %s.token, udn = %s.udn, "WebRenderer session removed");
-        }
-        session
-    }
-
-    pub fn list_sessions(&self) -> Vec<Arc<WebRendererSession>> {
-        self.sessions.read().values().cloned().collect()
-    }
-
-    fn spawn_cleanup_task(&self) {
-        let sessions = self.sessions.clone();
-        let timeout = self.timeout_duration;
-
-        tokio::spawn(async move {
-            let mut interval = tokio::time::interval(Duration::from_secs(60));
-            loop {
-                interval.tick().await;
-
-                let now = SystemTime::now();
-                let mut to_remove = Vec::new();
-
-                {
-                    let sessions_guard = sessions.read();
-                    for (token, session) in sessions_guard.iter() {
-                        let last = session.last_activity.read();
-                        if let Ok(elapsed) = now.duration_since(*last) {
-                            if elapsed > timeout {
-                                to_remove.push(token.clone());
-                            }
-                        }
-                    }
-                }
-
-                if !to_remove.is_empty() {
-                    let mut sessions_guard = sessions.write();
-                    for token in to_remove {
-                        sessions_guard.remove(&token);
-                        tracing::info!(token = %token, "Session expired and removed");
-                    }
-                }
-            }
-        });
-    }
-}
diff --git a/pmowebrenderer/src/state.rs b/pmowebrenderer/src/state.rs
index 9fa5c3f9..0f13415d 100644
--- a/pmowebrenderer/src/state.rs
+++ b/pmowebrenderer/src/state.rs
@@ -1,10 +1,9 @@
-//! État partagé du renderer (backend ↔ navigateur)
+//! État partagé du renderer (backend ↔ pipeline)
 
 use parking_lot::RwLock;
 use std::sync::Arc;
-use tokio::sync::mpsc;
 
-use crate::messages::{PlaybackState, ServerMessage};
+use crate::messages::PlaybackState;
 
 /// État temps-réel du renderer (partagé backend ↔ navigateur)
 #[derive(Debug, Clone)]
@@ -38,34 +37,3 @@ impl Default for RendererState {
 
 /// Alias pour l'état partagé
 pub type SharedState = Arc<RwLock<RendererState>>;
-
-/// Sender WebSocket partagé et remplaçable entre les reconnexions.
-///
-/// Les handlers UPnP capturent ce `Arc` à la création du device. À chaque
-/// reconnexion WebSocket (reload de page), on remplace le sender interne via
-/// `set()`, sans avoir à recréer le device ni ses handlers.
-#[derive(Clone)]
-pub struct SharedSender(Arc<RwLock<Option<mpsc::UnboundedSender<ServerMessage>>>>);
-
-impl SharedSender {
-    pub fn new(sender: mpsc::UnboundedSender<ServerMessage>) -> Self {
-        Self(Arc::new(RwLock::new(Some(sender))))
-    }
-
-    /// Envoie un message au navigateur. Ignore silencieusement si déconnecté.
-    pub fn send(&self, msg: ServerMessage) {
-        if let Some(tx) = self.0.read().as_ref() {
-            let _ = tx.send(msg);
-        }
-    }
-
-    /// Remplace le sender (appelé à la reconnexion WebSocket).
-    pub fn set(&self, sender: mpsc::UnboundedSender<ServerMessage>) {
-        *self.0.write() = Some(sender);
-    }
-
-    /// Retire le sender (appelé à la déconnexion).
-    pub fn clear(&self) {
-        *self.0.write() = None;
-    }
-}
diff --git a/pmowebrenderer/src/stream.rs b/pmowebrenderer/src/stream.rs
new file mode 100644
index 00000000..fa28a19a
--- /dev/null
+++ b/pmowebrenderer/src/stream.rs
@@ -0,0 +1,63 @@
+//! Handler HTTP GET /api/webrenderer/{id}/stream
+//!
+//! Sert le flux FLAC d'une instance WebRenderer via DirectFlacSink.
+//!
+//! Reconnectable : appelé à chaque Play, crée un nouveau pipe + encodeur.
+
+use axum::{
+    body::Body,
+    extract::{Path, State},
+    http::{
+        StatusCode,
+        header::{CACHE_CONTROL, CONNECTION, CONTENT_TYPE},
+    },
+    response::{IntoResponse, Response},
+};
+use std::sync::Arc;
+use tokio_util::io::ReaderStream;
+use tracing::info;
+
+use crate::registry::RendererRegistry;
+
+/// GET /api/webrenderer/{id}/stream
+///
+/// Crée un nouveau pipe FLAC à chaque connexion (chaque Play).
+/// Le flux reste ouvert jusqu'à ce que le client se déconnecte (Stop).
+/// Les morceaux s'enchaînent en gapless dans le même flux.
+///
+/// Safari envoie un Range header (bytes=0-) et exige Accept-Ranges: bytes.
+/// On répond 206 Partial Content si un Range header est présent, sinon 200.
+pub async fn stream_handler(
+    State(registry): State<Arc<RendererRegistry>>,
+    Path(instance_id): Path<String>,
+) -> impl IntoResponse {
+    info!(instance_id = %instance_id, "FLAC stream client connecting");
+
+    let handle = match registry.get_flac_handle(&instance_id) {
+        Some(h) => h,
+        None => {
+            return (
+                StatusCode::NOT_FOUND,
+                format!("No WebRenderer instance for id={}", instance_id),
+            )
+                .into_response()
+        }
+    };
+
+    let stream = handle.subscribe();
+
+    info!(instance_id = %instance_id, "FLAC stream started");
+
+    // Toujours 200 OK pour un flux live de taille inconnue.
+    // Les navigateurs (Safari inclus) acceptent 200 pour l'audio streaming.
+    // Un Content-Range invalide (bytes 0-*/*) ferait rejeter le flux.
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, "audio/ogg; codecs=flac")
+        .header(CACHE_CONTROL, "no-store, no-transform")
+        .header(CONNECTION, "keep-alive")
+        .header("X-Content-Type-Options", "nosniff")
+        .body(Body::from_stream(ReaderStream::new(stream)))
+        .unwrap()
+        .into_response()
+}
diff --git a/pmowebrenderer/src/websocket.rs b/pmowebrenderer/src/websocket.rs
deleted file mode 100644
index 25a0d5c5..00000000
--- a/pmowebrenderer/src/websocket.rs
+++ /dev/null
@@ -1,646 +0,0 @@
-//! Handler WebSocket pour les connexions navigateur → WebRenderer
-
-use std::sync::Arc;
-use std::time::SystemTime;
-
-use axum::extract::ws::{Message, WebSocket};
-use axum::extract::{State, WebSocketUpgrade};
-use axum::response::IntoResponse;
-use futures::{SinkExt, StreamExt};
-use parking_lot::RwLock;
-use tokio::sync::mpsc;
-use uuid::Uuid;
-
-use pmoupnp::devices::DeviceInstance;
-use pmoupnp::variable_types::StateValue;
-#[cfg(not(feature = "pmoserver"))]
-use pmoupnp::UpnpModel;
-use pmoupnp::UpnpTypedInstance;
-
-use crate::messages::*;
-use crate::renderer::WebRendererFactory;
-use crate::session::{SessionManager, WebRendererSession};
-use crate::state::{RendererState, SharedState};
-
-#[cfg(feature = "pmoserver")]
-use pmocontrol::model::{RendererCapabilities, RendererProtocol};
-#[cfg(feature = "pmoserver")]
-use pmocontrol::{ControlPoint, DeviceId};
-
-/// État partagé du serveur WebSocket
-#[derive(Clone)]
-pub struct WebSocketState {
-    pub session_manager: Arc<SessionManager>,
-    #[cfg(feature = "pmoserver")]
-    pub control_point: Arc<ControlPoint>,
-}
-
-/// Handler pour la connexion WebSocket
-pub async fn websocket_handler(
-    ws: WebSocketUpgrade,
-    State(state): State<WebSocketState>,
-) -> impl IntoResponse {
-    tracing::info!("WebRenderer WebSocket upgrade request received");
-    ws.on_upgrade(move |socket: WebSocket| handle_socket(socket, state))
-}
-
-/// Gestion de la connexion WebSocket
-async fn handle_socket(socket: WebSocket, state: WebSocketState) {
-    tracing::info!("WebRenderer WebSocket connection established");
-    let (mut sink, mut stream) = socket.split();
-
-    // Canal pour envoyer des messages au navigateur
-    let (tx, mut rx) = mpsc::unbounded_channel::<ServerMessage>();
-
-    // Task pour envoyer les messages du canal vers le WebSocket
-    let send_task = tokio::spawn(async move {
-        while let Some(msg) = rx.recv().await {
-            if let Ok(json) = serde_json::to_string(&msg) {
-                if sink.send(Message::Text(json.into())).await.is_err() {
-                    break;
-                }
-            }
-        }
-    });
-
-    let mut session_token: Option<String> = None;
-    #[allow(unused_variables, unused_assignments, unused_mut)]
-    let mut device_udn: Option<String> = None;
-
-    // Boucle de réception des messages du navigateur
-    while let Some(msg_result) = stream.next().await {
-        match msg_result {
-            Ok(Message::Text(text)) => {
-                tracing::info!("WebRenderer received text message: {}", &text);
-                match serde_json::from_str::<ClientMessage>(&text) {
-                    Ok(ClientMessage::Init { capabilities }) => {
-                        tracing::info!("WebRenderer Init received, creating renderer...");
-                        // Créer ou reconnecter le renderer UPnP pour ce navigateur.
-                        match create_renderer_for_browser(&capabilities, tx.clone(), &state).await {
-                            Ok(session) => {
-                                tracing::info!("WebRenderer create_renderer_for_browser OK");
-                                let token = session.token.clone();
-                                let udn = session.udn.clone();
-
-                                let model = session.device_instance.get_model();
-
-                                // Envoyer la confirmation au navigateur
-                                let _ = tx.send(ServerMessage::SessionCreated {
-                                    token: token.clone(),
-                                    renderer_info: RendererInfo {
-                                        udn: udn.clone(),
-                                        friendly_name: model.friendly_name().to_string(),
-                                        model_name: model.model_name().to_string(),
-                                        description_url: format!(
-                                            "{}{}",
-                                            session.device_instance.base_url(),
-                                            session.device_instance.description_route()
-                                        ),
-                                    },
-                                });
-
-                                // Si une URI est déjà chargée (reconnexion en cours de lecture),
-                                // envoyer l'état complet pour que le navigateur puisse reprendre.
-                                {
-                                    let s = session.state.read();
-                                    if s.current_uri.is_some() {
-                                        let _ = tx.send(ServerMessage::StateSync {
-                                            current_uri: s.current_uri.clone(),
-                                            current_metadata: s.current_metadata.clone(),
-                                            next_uri: s.next_uri.clone(),
-                                            next_metadata: s.next_metadata.clone(),
-                                            playback_state: s.playback_state.clone(),
-                                            position: s.position.clone(),
-                                            volume: s.volume,
-                                            mute: s.mute,
-                                        });
-                                        tracing::info!(
-                                            udn = %udn,
-                                            state = ?s.playback_state,
-                                            "WebRenderer: sent StateSync to reconnected browser"
-                                        );
-                                    }
-                                }
-
-                                session_token = Some(token.clone());
-                                #[cfg(feature = "pmoserver")]
-                                { device_udn = Some(udn.clone()); }
-
-                                state.session_manager.add_session(session);
-
-                                tracing::info!(
-                                    token = %token,
-                                    udn = %udn,
-                                    "WebRenderer initialized for browser: {}",
-                                    capabilities.user_agent
-                                );
-                            }
-                            Err(e) => {
-                                tracing::error!("Failed to create WebRenderer: {:?}", e);
-                                break;
-                            }
-                        }
-                    }
-                    Ok(ClientMessage::StateUpdate { state: new_state }) => {
-                        if let Some(ref token) = session_token {
-                            if let Some(session) = state.session_manager.get_session(token) {
-                                {
-                                    session.state.write().playback_state = new_state.clone();
-                                }
-                                update_transport_state_var(&session.device_instance, &new_state)
-                                    .await;
-                            }
-                        }
-                    }
-                    Ok(ClientMessage::PositionUpdate { position, duration }) => {
-                        if let Some(ref token) = session_token {
-                            if let Some(session) = state.session_manager.get_session(token) {
-                                {
-                                    let mut s = session.state.write();
-                                    s.position = Some(position.clone());
-                                    s.duration = Some(duration.clone());
-                                }
-                                update_position_vars(
-                                    &session.device_instance,
-                                    &position,
-                                    &duration,
-                                )
-                                .await;
-                            }
-                        }
-                    }
-                    Ok(ClientMessage::MetadataUpdate { metadata }) => {
-                        if let Some(ref token) = session_token {
-                            if let Some(session) = state.session_manager.get_session(token) {
-                                let didl = build_didl_from_metadata(&metadata);
-                                {
-                                    session.state.write().current_metadata = Some(didl.clone());
-                                }
-                                update_metadata_var(&session.device_instance, &didl).await;
-                            }
-                        }
-                    }
-                    Ok(ClientMessage::VolumeUpdate { volume, mute }) => {
-                        if let Some(ref token) = session_token {
-                            if let Some(session) = state.session_manager.get_session(token) {
-                                {
-                                    let mut s = session.state.write();
-                                    s.volume = volume;
-                                    s.mute = mute;
-                                }
-                                update_volume_vars(&session.device_instance, volume, mute).await;
-                            }
-                        }
-                    }
-                    Ok(ClientMessage::TrackEnded) => {
-                        if let Some(ref token) = session_token {
-                            if let Some(session) = state.session_manager.get_session(token) {
-                                let (next_uri, next_metadata, had_next) = {
-                                    let mut s = session.state.write();
-                                    let uri = s.next_uri.take();
-                                    let meta = s.next_metadata.take();
-                                    let had_next = uri.is_some();
-                                    s.current_uri = uri.clone();
-                                    s.current_metadata = meta.clone();
-                                    s.next_uri = None;
-                                    s.next_metadata = None;
-                                    s.position = None;
-                                    s.duration = None;
-                                    // Si on avait une piste suivante (gapless), on reste en Playing.
-                                    // Sinon, on reste en Stopped pour que le watcher déclenche l'auto-advance.
-                                    if had_next {
-                                        s.playback_state = PlaybackState::Playing;
-                                    }
-                                    // Si had_next == false, le navigateur a déjà envoyé state_update:STOPPED,
-                                    // donc s.playback_state est déjà Stopped. On le laisse tel quel.
-                                    (uri, meta, had_next)
-                                };
-                                let new_state = if had_next {
-                                    PlaybackState::Playing
-                                } else {
-                                    PlaybackState::Stopped
-                                };
-                                update_transport_state_var(
-                                    &session.device_instance,
-                                    &new_state,
-                                )
-                                .await;
-                                // Mettre à jour AVTransportURI pour que le ControlPoint
-                                // voie la nouvelle piste courante et envoie SetNextAVTransportURI
-                                update_uri_vars(
-                                    &session.device_instance,
-                                    next_uri.as_deref().unwrap_or(""),
-                                    next_metadata.as_deref().unwrap_or(""),
-                                    "",  // next_uri vide : le ControlPoint le remplira
-                                    "",
-                                )
-                                .await;
-                                // Si c'était une transition gapless (on avait une piste suivante),
-                                // avancer l'index de la queue dans le ControlPoint et prefetch la piste N+2.
-                                // Si pas de piste suivante, le watcher verra STOPPED et déclenchera l'auto-advance.
-                                #[cfg(feature = "pmoserver")]
-                                if had_next {
-                                    let udn = session.udn.clone();
-                                    let cp = state.control_point.clone();
-                                    tokio::spawn(async move {
-                                        cp.advance_queue_and_prefetch(
-                                            &pmocontrol::DeviceId(udn),
-                                        );
-                                    });
-                                }
-                                tracing::debug!(
-                                    uri = ?next_uri,
-                                    had_next,
-                                    "WebRenderer TrackEnded: advanced to next track"
-                                );
-                            }
-                        }
-                    }
-                    Ok(ClientMessage::Pong) => {}
-                    Err(e) => {
-                        tracing::warn!(error = %e, "Failed to parse client message");
-                    }
-                }
-            }
-            Ok(Message::Binary(b)) => {
-                tracing::warn!("WebRenderer received binary message ({} bytes)", b.len());
-            }
-            Ok(Message::Close(_)) => {
-                tracing::info!("WebRenderer WebSocket closed by client");
-                break;
-            }
-            Err(e) => {
-                tracing::error!("WebSocket error: {}", e);
-                break;
-            }
-            _ => {}
-        }
-    }
-
-    // Cleanup à la déconnexion
-    tracing::info!("WebRenderer WebSocket handler exiting (session_token={:?})", session_token);
-    if let Some(token) = session_token {
-        state.session_manager.remove_session(&token);
-    }
-
-    // Marquer le renderer comme offline dans le ControlPoint
-    #[cfg(feature = "pmoserver")]
-    if let Some(ref udn) = device_udn {
-        if let Ok(mut registry) = state.control_point.registry().write() {
-            registry.device_says_byebye(udn);
-        }
-        tracing::info!(udn = %udn, "WebRenderer disconnected and marked offline");
-    }
-
-    send_task.abort();
-}
-
-/// Crée ou reconnecte un DeviceInstance UPnP pour un navigateur.
-///
-/// - Première connexion : crée le device, l'enregistre, crée la session.
-/// - Reconnexion (reload) : retrouve la session existante par UDN, met à jour le
-///   `SharedSender` avec le nouveau tx WebSocket (les handlers continuent de fonctionner),
-///   et crée une nouvelle session avec un nouveau token.
-async fn create_renderer_for_browser(
-    capabilities: &BrowserCapabilities,
-    ws_sender: mpsc::UnboundedSender<ServerMessage>,
-    ws_state: &WebSocketState,
-) -> Result<Arc<WebRendererSession>, crate::error::WebRendererError> {
-    let token = Uuid::new_v4().to_string();
-
-    // Persister l'UDN dérivé de l'instance_id dans la config pour que device_instance.rs
-    // le retrouve de façon déterministe. La clé ("MediaRenderer", instance_id) est unique
-    // par onglet/navigateur et stable entre les reloads.
-    let instance_udn = capabilities.instance_id.clone();
-    if let Err(e) = pmoconfig::get_config().set_device_udn(
-        "MediaRenderer",
-        &instance_udn,
-        instance_udn.clone(),
-    ) {
-        tracing::warn!("WebRenderer: failed to persist UDN in config: {:?}", e);
-    }
-
-    // UDN normalisé tel que stocké dans le DEVICE_REGISTRY (sans préfixe "uuid:")
-    let candidate_udn = instance_udn.to_ascii_lowercase();
-    // UDN avec préfixe "uuid:" pour le ControlPoint et la session
-    let full_udn = format!("uuid:{}", candidate_udn);
-
-    // ── Reconnexion : session existante par UDN ───────────────────────────────
-    // Si une session avec ce même UDN existe encore dans le SessionManager, on
-    // met à jour son SharedSender (les handlers UPnP enverront vers le nouveau WS).
-    if let Some(existing_session) = ws_state.session_manager.get_session_by_udn(&full_udn) {
-        tracing::info!(udn = %full_udn, "WebRenderer: reconnecting via existing session");
-        existing_session.shared_sender.set(ws_sender.clone());
-
-        #[cfg(feature = "pmoserver")]
-        register_with_control_point(&existing_session.device_instance, ws_state)?;
-
-        // Nouvelle session avec nouveau token, mais même device/state/sender partagés
-        let session = Arc::new(WebRendererSession {
-            token,
-            udn: full_udn,
-            device_instance: existing_session.device_instance.clone(),
-            shared_sender: existing_session.shared_sender.clone(),
-            state: existing_session.state.clone(),
-            created_at: existing_session.created_at,
-            last_activity: existing_session.last_activity.clone(),
-        });
-        return Ok(session);
-    }
-
-    // ── Première connexion : création complète ────────────────────────────────
-
-    // Enregistrer le device via UpnpServerExt (gère base_url, register_urls, DEVICE_REGISTRY)
-    // Retourne (DeviceInstance, SharedSender effectif, SharedState effective pour cette session)
-    #[cfg(feature = "pmoserver")]
-    let (di, shared_sender, shared_state) = {
-        use pmoupnp::UpnpServerExt;
-
-        tracing::info!("WebRenderer: candidate UDN = {}", candidate_udn);
-
-        // Vérifier si un device avec ce même UDN est déjà dans le DEVICE_REGISTRY
-        // (cas où la session a expiré mais le device est encore enregistré).
-        let server_arc =
-            pmoserver::get_server().ok_or(crate::error::WebRendererError::ServerNotAvailable)?;
-        let existing_di = {
-            let server = server_arc.read().await;
-            server.get_device(&candidate_udn)
-        };
-
-        if let Some(di) = existing_di {
-            tracing::info!(udn = %candidate_udn, "WebRenderer: reusing device from registry (session expired)");
-            // Mettre à jour le SharedSender de ce device (session supprimée mais device toujours dans registry).
-            // Le SharedSender et le SharedState sont ceux capturés dans les handlers du di existant.
-            let effective_sender = if let Some(existing_sender) = ws_state.session_manager.get_sender_by_udn(&full_udn) {
-                existing_sender.set(ws_sender);
-                tracing::info!(udn = %full_udn, "WebRenderer: updated SharedSender for reused device");
-                existing_sender
-            } else {
-                // Fallback : ne devrait pas arriver mais on crée un sender neuf
-                tracing::warn!(udn = %full_udn, "WebRenderer: no SharedSender found for reused device");
-                let new_state: SharedState = Arc::new(RwLock::new(RendererState::default()));
-                let (_, new_sender) = WebRendererFactory::create_device_with_name(
-                    &instance_udn, &capabilities.user_agent, ws_sender, new_state.clone(),
-                ).map_err(|e| crate::error::WebRendererError::DeviceCreationError(e.to_string()))?;
-                new_sender
-            };
-            let effective_state = ws_state.session_manager.get_state_by_udn(&full_udn)
-                .unwrap_or_else(|| Arc::new(RwLock::new(RendererState::default())));
-            register_with_control_point(&di, ws_state)?;
-            (di, effective_sender, effective_state)
-        } else {
-            // Véritablement première connexion : créer device + state + sender
-            let new_state: SharedState = Arc::new(RwLock::new(RendererState::default()));
-            tracing::info!("WebRenderer: creating device model...");
-            let (device, new_sender) = WebRendererFactory::create_device_with_name(
-                &instance_udn,
-                &capabilities.user_agent,
-                ws_sender,
-                new_state.clone(),
-            )
-            .map_err(|e| crate::error::WebRendererError::DeviceCreationError(e.to_string()))?;
-            tracing::info!("WebRenderer: device model created");
-
-            let device = Arc::new(device);
-            tracing::info!("WebRenderer: registering new device...");
-            let di = {
-                let mut server = server_arc.write().await;
-                server
-                    .register_device(device)
-                    .await
-                    .map_err(|e| crate::error::WebRendererError::RegistrationError(e.to_string()))?
-            };
-            tracing::info!("WebRenderer: device registered");
-            register_with_control_point(&di, ws_state)?;
-            (di, new_sender, new_state)
-        }
-    };
-
-    #[cfg(not(feature = "pmoserver"))]
-    let (di, shared_sender, shared_state) = {
-        let new_state: SharedState = Arc::new(RwLock::new(RendererState::default()));
-        let (device, new_sender) = WebRendererFactory::create_device_with_name(
-            &instance_udn,
-            &capabilities.user_agent,
-            ws_sender,
-            new_state.clone(),
-        )
-        .map_err(|e| crate::error::WebRendererError::DeviceCreationError(e.to_string()))?;
-        (Arc::new(device).create_instance(), new_sender, new_state)
-    };
-
-    let session = Arc::new(WebRendererSession {
-        token,
-        udn: full_udn,
-        device_instance: di,
-        shared_sender,
-        state: shared_state,
-        created_at: SystemTime::now(),
-        last_activity: Arc::new(RwLock::new(SystemTime::now())),
-    });
-
-    Ok(session)
-}
-
-/// Enregistre le DeviceInstance auprès du ControlPoint comme un renderer
-#[cfg(feature = "pmoserver")]
-fn register_with_control_point(
-    di: &Arc<DeviceInstance>,
-    ws_state: &WebSocketState,
-) -> Result<(), crate::error::WebRendererError> {
-    let base_url = di.base_url().to_string();
-    let udn = di.udn().to_ascii_lowercase();
-    // Préfixer avec "uuid:" pour correspondre au format SSDP et éviter les doublons
-    let udn_with_prefix = format!("uuid:{}", udn);
-    let device_route = di.route();
-    let model = di.get_model();
-
-    let avtransport_control_url = Some(format!(
-        "{}{}/service/AVTransport/control",
-        base_url, device_route
-    ));
-    let rendering_control_url = Some(format!(
-        "{}{}/service/RenderingControl/control",
-        base_url, device_route
-    ));
-    let connection_manager_url = Some(format!(
-        "{}{}/service/ConnectionManager/control",
-        base_url, device_route
-    ));
-
-    let renderer_info = pmocontrol::RendererInfo::make(
-        DeviceId(udn_with_prefix.clone()),
-        udn_with_prefix.clone(),
-        model.friendly_name().to_string(),
-        model.model_name().to_string(),
-        "PMOMusic".to_string(),
-        RendererProtocol::UpnpAvOnly,
-        RendererCapabilities {
-            has_avtransport: true,
-            has_avtransport_set_next: true,
-            has_rendering_control: true,
-            has_connection_manager: true,
-            ..Default::default()
-        },
-        format!("{}{}", base_url, di.description_route()),
-        "PMOMusic WebRenderer/1.0".to_string(),
-        Some("urn:schemas-upnp-org:service:AVTransport:1".to_string()),
-        avtransport_control_url,
-        Some("urn:schemas-upnp-org:service:RenderingControl:1".to_string()),
-        rendering_control_url,
-        Some("urn:schemas-upnp-org:service:ConnectionManager:1".to_string()),
-        connection_manager_url,
-        None, // oh_playlist_service_type
-        None, // oh_playlist_control_url
-        None, // oh_playlist_event_sub_url
-        None, // oh_info_service_type
-        None, // oh_info_control_url
-        None, // oh_info_event_sub_url
-        None, // oh_time_service_type
-        None, // oh_time_control_url
-        None, // oh_time_event_sub_url
-        None, // oh_volume_service_type
-        None, // oh_volume_control_url
-        None, // oh_radio_service_type
-        None, // oh_radio_control_url
-        None, // oh_product_service_type
-        None, // oh_product_control_url
-    );
-
-    if let Ok(mut registry) = ws_state.control_point.registry().write() {
-        // max_age élevé car pas de SSDP — cleanup à la déconnexion WS
-        registry.push_renderer(&renderer_info, 86400);
-    }
-
-    tracing::info!(udn = %udn, "WebRenderer registered with ControlPoint");
-    Ok(())
-}
-
-// ─── Mise à jour des StateVarInstance UPnP ──────────────────────────────────
-
-async fn update_transport_state_var(di: &DeviceInstance, state: &PlaybackState) {
-    let upnp_state = match state {
-        PlaybackState::Stopped => "STOPPED",
-        PlaybackState::Playing => "PLAYING",
-        PlaybackState::Paused => "PAUSED_PLAYBACK",
-        PlaybackState::Transitioning => "TRANSITIONING",
-    };
-
-    if let Some(service) = di.get_service("AVTransport") {
-        if let Some(var) = service.get_variable("TransportState") {
-            let _ = var
-                .set_value(StateValue::String(upnp_state.to_string()))
-                .await;
-        }
-    }
-}
-
-async fn update_position_vars(di: &DeviceInstance, position: &str, duration: &str) {
-    if let Some(service) = di.get_service("AVTransport") {
-        if let Some(var) = service.get_variable("RelativeTimePosition") {
-            let _ = var
-                .set_value(StateValue::String(position.to_string()))
-                .await;
-        }
-        if let Some(var) = service.get_variable("AbsoluteTimePosition") {
-            let _ = var
-                .set_value(StateValue::String(position.to_string()))
-                .await;
-        }
-        if let Some(var) = service.get_variable("CurrentTrackDuration") {
-            let _ = var
-                .set_value(StateValue::String(duration.to_string()))
-                .await;
-        }
-    }
-}
-
-async fn update_uri_vars(
-    di: &DeviceInstance,
-    current_uri: &str,
-    current_metadata: &str,
-    next_uri: &str,
-    next_metadata: &str,
-) {
-    if let Some(service) = di.get_service("AVTransport") {
-        if let Some(var) = service.get_variable("AVTransportURI") {
-            let _ = var
-                .set_value(StateValue::String(current_uri.to_string()))
-                .await;
-        }
-        if let Some(var) = service.get_variable("AVTransportURIMetaData") {
-            let _ = var
-                .set_value(StateValue::String(current_metadata.to_string()))
-                .await;
-        }
-        if let Some(var) = service.get_variable("AVTransportNextURI") {
-            let _ = var
-                .set_value(StateValue::String(next_uri.to_string()))
-                .await;
-        }
-        if let Some(var) = service.get_variable("AVTransportNextURIMetaData") {
-            let _ = var
-                .set_value(StateValue::String(next_metadata.to_string()))
-                .await;
-        }
-    }
-}
-
-async fn update_metadata_var(di: &DeviceInstance, didl: &str) {
-    if let Some(service) = di.get_service("AVTransport") {
-        if let Some(var) = service.get_variable("CurrentTrackMetaData") {
-            let _ = var.set_value(StateValue::String(didl.to_string())).await;
-        }
-    }
-}
-
-async fn update_volume_vars(di: &DeviceInstance, volume: u16, mute: bool) {
-    if let Some(service) = di.get_service("RenderingControl") {
-        if let Some(var) = service.get_variable("Volume") {
-            let _ = var.set_value(StateValue::UI2(volume)).await;
-        }
-        if let Some(var) = service.get_variable("Mute") {
-            let _ = var.set_value(StateValue::Boolean(mute)).await;
-        }
-    }
-}
-
-fn build_didl_from_metadata(metadata: &TrackMetadata) -> String {
-    use pmodidl::{DIDLLite, Item, Resource};
-    use pmoutils::ToXmlElement;
-
-    let item = Item {
-        id: "0".to_string(),
-        parent_id: "-1".to_string(),
-        restricted: Some("1".to_string()),
-        title: metadata
-            .title
-            .clone()
-            .unwrap_or_else(|| "Unknown".to_string()),
-        creator: None,
-        class: "object.item.audioItem.musicTrack".to_string(),
-        artist: metadata.artist.clone(),
-        album: metadata.album.clone(),
-        genre: None,
-        album_art: metadata.album_art_uri.clone(),
-        album_art_pk: None,
-        date: None,
-        original_track_number: None,
-        resources: vec![Resource {
-            protocol_info: "http-get:*:audio/*:*".to_string(),
-            duration: metadata.duration.clone(),
-            url: "".to_string(),
-            bits_per_sample: None,
-            sample_frequency: None,
-            nr_audio_channels: None,
-        }],
-        descriptions: vec![],
-    };
-
-    let didl = DIDLLite {
-        items: vec![item],
-        ..Default::default()
-    };
-
-    didl.to_xml()
-}
diff --git a/version.txt b/version.txt
index 0c4b4549..a1dad2aa 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-0.3.22
+0.3.23