Actualiser version.txt

Reviewed-on: #37

.claude-env

@@ -0,0 +1,3 @@
+# Configuration PATH pour Claude Code
+# Ce fichier sera lu automatiquement pour configurer l'environnement
+export PATH="/Users/coissac/mamba/condabin:/opt/homebrew/lib/ruby/gems/3.4.0/bin:/opt/homebrew/opt/ruby/bin:/Users/coissac/go/bin:/Users/coissac/.cargo/bin:/Users/coissac/.modular/pkg/packages.modular.com_mojo/bin:/Applications/quarto/bin:/Users/coissac/.vscode-oss/extensions/vadimcn.vscode-lldb-1.12.0/bin:/Library/Frameworks/Python.framework/Versions/3.12/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/opt/pmk/env/global/bin:/opt/X11/bin:/usr/local/dorado/dorado-0.9.5-osx-arm64/bin:/usr/local/go/bin:/usr/local/src/last-main/bin:/Users/coissac/travail/__MOI__/GO/obitools4/build:/opt/podman/bin:/Applications/quarto/bin:/Users/coissac/.cargo/bin:/Users/coissac/.vscode-oss/extensions/vadimcn.vscode-lldb-1.12.0/bin:/Users/coissac/.vscode-oss/extensions/ms-python.debugpy-2025.14.1-darwin-arm64/bundled/scripts/noConfigScripts:/Users/coissac/.orbstack/bin"

.claude/CLAUDE.md

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

.dockerignore

@@ -0,0 +1,70 @@
+# Build artifacts
+target/
+**/target/
+
+# Webapp build artifacts and dependencies
+pmoapp/webapp/node_modules/
+pmoapp/webapp/dist/
+**/node_modules/
+
+# Git
+.git/
+.gitignore
+.jj/
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# macOS
+.DS_Store
+
+# Cache directories
+cache/
+.pmomusic/
+
+# Log files
+*.log
+
+# Documentation
+doc/
+*.md
+!Readme.md
+
+# Test files
+test_upnp/
+examples/
+
+# Temporary files
+*.tmp
+*.temp
+*.pcap
+
+# Database files
+db/
+
+# Old code and backups
+old_code/
+*.txt
+!Cargo.lock
+
+# Development tools
+tools/
+gupnp-tools/
+
+# Build scripts (we have them in the Dockerfile)
+Makefile
+setup-deps.sh
+setup-env.sh
+
+# SVG and other assets not needed for runtime
+*.svg
+
+# Audio test files
+*.ogg
+*.flac
+*.wav
+*.mp3

.gitea/workflows/build-push.yaml

@@ -0,0 +1,29 @@
+name: Build and Push Docker Image
+
+on:
+  push:
+    branches:
+      - main  # Changez cela si votre branche principale a un autre nom
+    
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Setup cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.npm
+          key: dont-cache-${{ github.run_id }}        
+      - name: Build and push image
+        uses: https://gargoton.petite-maison-orange.fr/pmo-actions/build-push-image@main
+        with:
+          image_name: public/pmomusic
+          image_tags: latest
+          no_cache: true
+          version_file: version.txt
+          check_uuid: 82a30d23-b3bd-4199-9237-776965831d20
+
+
+  

.gitignore

@@ -1,3 +1,5 @@
+.ollama
+.ollamacode
 /bin/
 /pkg/
 /vendor/
@@ -6,14 +8,24 @@
 **/*.o
 **/*.o.d
 **/*.a
+**/*.flac 
+**/*.aif
+**/*.aiff
+**/*.wav
+**/*.opus
+**/*.mp4
+**/*.mp3
+**/*.ogg
 xxx
 /dcai/
 **/.pmomusic.yml
 **/.pmomusic_covers/**
-**/.DS_Strore/**
-**/.DS_Strore
-/target/
-.pmomusic_covers
+**/.pmomusic_audio/**
+/.pmomusic
+.DS_Store
+target
+/.pmomusic_covers
+/.pmomusic_audio/** 
 C/src/soxr-0.1.3/Release/tests
 **/Release/
 **/Debug/
@@ -22,3 +34,12 @@ xxx
 xx
 all.txt
 pmo_src.txt
+upmpdcli/
+/*.xml
+test_upnp*.cargo/
+.cargo/
+setup-env.sh
+cache
+gupnp-tools
+pmo*_[0_9]*.txt
+webapp_[0_9]*.txt

.pmomusic.yml

@@ -1,9 +0,0 @@
-devices:
-  mediarenderer:
-    fakerenderer:
-      udn: d7eaad15-7d21-4411-926a-bc1eea0713db
-  mediaserver:
-    qobuz:
-      udn: 28963b75-4c5f-4da7-b10e-ffafd
-host:
-  http_port: '8080'

.pmomusic.yml.example

@@ -0,0 +1,28 @@
+host:
+  http_port: '8080'
+  cover_cache:
+    directory: ./.pmomusic_covers
+    size: 2000
+  audio_cache:
+    directory: ./.pmomusic_audio
+    size: 500
+  logger:
+    buffer_capacity: 200
+    enable_console: true
+    min_level: TRACE
+  mediarenderer:
+    mpd_renderer: null
+  mediaserver:
+    qobuz:
+      udn: uuid:28963b75-4c5f-4da7-b10e-ffafd
+accounts:
+  qobuz:
+    username: your-email@example.com
+    password: 'YOUR_PASSWORD_HERE'
+devices:
+  mediarenderer:
+    pmo_mediarenderer:
+      udn: 15a13316-daac-47f0-b64e-47e56f5e3b51
+  mediaserver:
+    pmo_mediaserver:
+      udn: 23df0bfa-cfef-4724-b731-00f66fadf176

.vscode/settings.json

@@ -1,7 +1,37 @@
 {
-    "makefile.configureOnOpen": false,
-    "git.enabled": false,
-    "claude-code.environmentVariables": [
-        
-    ]
-}
+  "makefile.configureOnOpen": false,
+  "git.enabled": false,
+  "claude-code.environmentVariables": [],
+
+  // Exclusions de fichiers/dossiers inutiles pour Rust Analyzer
+  "files.exclude": {
+    "target": true,
+    "**/target": true,
+    "node_modules": true,
+    "tests/huge_benchmarks": true,
+    "examples": true,
+    "docs": true
+  },
+  // Rust Analyzer settings
+  "rust-analyzer.rustupPath": "/Users/coissac/.cargo/bin/rustup",
+  "rust-analyzer.cargoPath": "/Users/coissac/.cargo/bin/cargo",
+  "rust-analyzer.rustcSource": "discover",
+  "rust-analyzer.procMacro.enable": true,
+  "rust-analyzer.numThreads": 4,
+  "rust-analyzer.cargo.loadOutDirsFromCheck": false,
+  "rust-analyzer.checkOnSave.enable": true,
+  "rust-analyzer.checkOnSave.command": "check", 
+  "rust-analyzer.checkOnSave.extraArgs": ["--all-features"],
+  "rust-analyzer.exclude": [
+    "target",
+    "tests/huge_benchmarks",
+    "examples",
+    "docs"
+  ],
+  "rust-analyzer.server.extraEnv": {
+    "RA_LARGE_PROJECT": "1"
+},
+"rust-analyzer.runnables.command": null,
+"rust-analyzer.server.path": null,
+"rust-analyzer.cargo.allTargets": true,
+}

BROWSEMETADATA_FIX.md

@@ -0,0 +1,121 @@
+# BrowseMetadata Fix for Radio Paradise - PMO Music
+
+**Date:** 2025-11-27
+**Issue:** gupnp-av-cp failed to get metadata for live streams and history containers
+
+## Problem
+
+UPnP clients (like gupnp-av-cp) were unable to get metadata for:
+- Live stream items (e.g., `radio-paradise:channel:mellow:live`)
+- History containers (e.g., `radio-paradise:channel:mellow:history`)
+
+Error:
+```
+Failed to get metadata for 'radio-paradise:channel:mellow:live'
+Failed to get metadata for 'radio-paradise:channel:mellow:history'
+```
+
+## Root Cause
+
+The UPnP ContentDirectory service has two browse modes:
+- **BrowseMetadata**: Get metadata for a specific object (item or container)
+- **BrowseDirectChildren**: Get the children of a container
+
+The `ContentHandler::browse_metadata()` was calling `source.browse()` for all objects, but:
+1. The `MusicSource::browse()` trait method is designed to return children, not object metadata
+2. For leaf items (LiveStream, HistoryTrack), `RadioParadiseSource::browse()` was rejecting them as "cannot be browsed"
+3. The trait doesn't provide a way to distinguish between BrowseMetadata and BrowseDirectChildren requests
+
+## Solution
+
+### 1. Modified ContentHandler ([pmomediaserver/src/content_handler.rs](pmomediaserver/src/content_handler.rs))
+
+- `browse_metadata()` now tries `get_item()` first for leaf items before falling back to `browse()`
+- This allows proper metadata retrieval for items (LiveStream, HistoryTrack)
+
+### 2. Modified RadioParadiseSource ([pmoparadise/src/source.rs](pmoparadise/src/source.rs))
+
+**For LiveStream items:**
+- `browse()` now returns `BrowseResult::Items([live_item])` with the item's metadata
+- This supports both BrowseMetadata (via ContentHandler) and direct browse calls
+
+**For HistoryTrack items:**
+- `browse()` now returns `BrowseResult::Items([track])` using `get_item()` internally
+- Properly retrieves track metadata from the history playlist
+
+**For History containers:**
+- `browse()` now returns `BrowseResult::Mixed { containers: [history_container], items: [tracks] }`
+- Provides both container metadata and its children in one result
+
+### 3. Added Container Filtering ([pmomediaserver/src/content_handler.rs](pmomediaserver/src/content_handler.rs))
+
+- `browse_result_to_didl()` now filters out containers that match the browsed `object_id`
+- Prevents containers from appearing as children of themselves
+- For History: BrowseDirectChildren returns only tracks, not the container
+
+## Files Modified
+
+1. ✅ [pmomediaserver/src/content_handler.rs](pmomediaserver/src/content_handler.rs)
+   - Lines 120-135: Try get_item() first in browse_metadata()
+   - Lines 290-310: Added object_id parameter and container filtering in browse_result_to_didl()
+   - Lines 212, 286: Updated callers to pass object_id
+
+2. ✅ [pmoparadise/src/source.rs](pmoparadise/src/source.rs)
+   - Lines 345-369: Modified History browse to return Mixed (container + items)
+   - Lines 371-377: Modified LiveStream browse to return item metadata
+   - Lines 379-383: Modified HistoryTrack browse to return track metadata
+
+## Validation
+
+### Live Stream Metadata ✅
+```bash
+curl -X POST -H "SOAPAction: ..." BrowseMetadata radio-paradise:channel:mellow:live
+```
+Returns:
+```xml
+<item id="radio-paradise:channel:mellow:live" parentID="radio-paradise:channel:mellow">
+  <dc:title>Unknown Title</dc:title>
+  <upnp:class>object.item.audioItem.audioBroadcast</upnp:class>
+  <res protocolInfo="http-get:*:audio/flac:*">http://.../radioparadise/stream/mellow/flac</res>
+</item>
+```
+
+### History Container Metadata ✅
+```bash
+curl -X POST -H "SOAPAction: ..." BrowseMetadata radio-paradise:channel:mellow:history
+```
+Returns:
+```xml
+<container id="radio-paradise:channel:mellow:history" parentID="radio-paradise:channel:mellow">
+  <dc:title>Mellow Mix - History</dc:title>
+  <upnp:class>object.container.playlistContainer</upnp:class>
+</container>
+```
+
+### History Children ✅
+```bash
+curl -X POST -H "SOAPAction: ..." BrowseDirectChildren radio-paradise:channel:mellow:history
+```
+Returns only track items (not the container itself)
+
+## Design Notes
+
+This solution works around a fundamental limitation in the `MusicSource` trait:
+- The `browse()` method doesn't receive the `browse_flag` parameter
+- It can't distinguish between BrowseMetadata and BrowseDirectChildren
+- We use `get_item()` for items and `browse()` for containers
+- Container filtering ensures correct BrowseDirectChildren behavior
+
+## Testing Checklist
+
+- [x] BrowseMetadata works for LiveStream items
+- [x] BrowseMetadata works for History containers
+- [x] BrowseDirectChildren works for History (returns only tracks)
+- [x] Container filtering prevents self-reference
+- [ ] Test with BubbleUPnP (user to verify)
+- [ ] Test with gupnp-av-cp (user to verify)
+
+## References
+
+- Original issue report: [UPNP_FIX_SUMMARY.md](UPNP_FIX_SUMMARY.md)
+- UPnP AV Architecture: https://openconnectivity.org/developer/specifications/upnp-resources/upnp/

Cargo.toml

@@ -1,3 +1,55 @@
 [workspace]
 resolver = "3"
-members = ["PMOMusic", "pmoupnp","pmoconfig", "pmoutils", "pmodidl", "pmoserver", "pmoapp"]
+members = [
+    "PMOMusic",
+    "pmoupnp",
+    "pmomediarenderer",
+    "pmomediaserver",
+    "pmoconfig",
+    "pmoutils",
+    "pmodidl",
+    "pmoserver",
+    "pmoapp",
+    "pmocache",
+    "pmocovers",
+    "pmoaudiocache",
+    "pmoaudio",
+    "pmoqobuz",
+    "pmoparadise",
+    "pmosource",
+    "pmoplaylist",
+    "pmoflac",
+    "pmometadata", "pmocontrol",
+]
+
+[workspace.dependencies]
+# Core
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+serde_yaml = "0.9"
+
+# Async runtime
+tokio = { version = "1.35", features = ["full"] }
+tokio-util = { version = "0.7", features = ["io"] }
+async-trait = "0.1"
+
+# Error handling
+anyhow = "1.0"
+thiserror = "2.0"  # ⚠️ Unifier sur 2.0 (vous avez 1.0 et 2.0)
+
+# Logging
+tracing = "0.1.41"
+tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
+
+# HTTP/XML
+reqwest = { version = "0.12", default-features = false }
+ureq = "3.1"
+quick-xml = { version = "0.38", features = ["serialize"] }  # ⚠️ Unifier 0.37→0.38
+
+# Utilities
+chrono = { version = "0.4", features = ["serde"] }
+uuid = { version = "1.18", features = ["v4"] }
+crossbeam-channel = "0.5"
+
+# Testing
+tokio-test = "0.4"

DEPENDENCIES.md

@@ -0,0 +1,72 @@
+## Diagramme des dépendances PMOMusic (crates internes)
+
+```mermaid
+graph TD
+
+    PMOMusic --> pmoapp
+    PMOMusic --> pmoaudio_ext
+    PMOMusic --> pmoaudiocache
+    PMOMusic --> pmocovers
+    PMOMusic --> pmoconfig
+    PMOMusic --> pmoserver
+    PMOMusic --> pmosource
+    PMOMusic --> pmoupnp
+    PMOMusic --> pmomediaserver
+    PMOMusic --> pmomediarenderer
+    PMOMusic --> pmoqobuz
+    PMOMusic --> pmoparadise
+
+    pmoaudio_ext --> pmoaudio
+    pmoaudio_ext --> pmocovers
+    pmoaudio_ext --> pmocache
+    pmoaudio_ext --> pmoaudiocache
+    pmoaudio_ext --> pmometadata
+    pmoaudio_ext --> pmoplaylist
+
+    pmoaudiocache --> pmocache
+    pmoaudiocache --> pmometadata
+
+    pmocovers --> pmocache
+
+    pmoplaylist --> pmocache
+    pmoplaylist --> pmoaudiocache
+    pmoplaylist --> pmometadata
+    pmoplaylist --> pmodidl
+
+    pmosource --> pmoaudiocache
+    pmosource --> pmocovers
+    pmosource --> pmocache
+    pmosource --> pmoplaylist
+    pmosource --> pmodidl
+    pmosource --> pmoconfig
+    pmosource --> pmoserver
+    pmosource --> pmoupnp
+
+    pmoparadise --> pmosource
+    pmoparadise --> pmoaudiocache
+    pmoparadise --> pmoplaylist
+    pmoparadise --> pmoserver
+    pmoparadise --> pmoconfig
+
+    pmoqobuz --> pmosource
+    pmoqobuz --> pmoaudiocache
+    pmoqobuz --> pmocovers
+    pmoqobuz --> pmoserver
+    pmoqobuz --> pmoconfig
+
+    pmomediaserver --> pmoserver
+    pmomediaserver --> pmosource
+    pmomediaserver --> pmoconfig
+    pmomediaserver --> pmocovers
+    pmomediaserver --> pmoaudiocache
+    pmomediaserver --> pmoplaylist
+    
+    pmoupnp --> pmoserver
+    pmoupnp --> pmocovers
+    pmoupnp --> pmoaudiocache
+    pmoupnp --> pmoplaylist
+    pmoupnp --> pmocache
+    pmoupnp --> pmoconfig
+```
+
+> Flèches = “dépend de”. Dépendances externes non représentées. Cette vue correspond aux features activées par défaut dans la workspace.

DOCKER.md

@@ -0,0 +1,302 @@
+# Docker Deployment Guide for PMOMusic
+
+Ce guide explique comment construire et déployer PMOMusic avec Docker.
+
+## Architecture
+
+Le Dockerfile utilise une approche multi-stage pour créer une image minimale :
+
+1. **Stage 1 (webapp-builder)** : Compile l'application Vue.js avec Node.js
+2. **Stage 2 (rust-builder)** : Compile le binaire Rust avec toutes ses dépendances
+3. **Stage 3 (runtime)** : Image finale minimale Debian Slim avec uniquement le binaire et les bibliothèques runtime
+
+### Avantages
+
+- **Binaire auto-contenu** : L'application web est embarquée dans le binaire Rust
+- **Image minimale** : ~200-300MB (vs plusieurs GB pour les images de build)
+- **Sécurité** : Exécution en tant qu'utilisateur non-root
+- **Reproductibilité** : Build complet et déterministe
+
+## Build de l'image
+
+### Option 1 : Build manuel avec Docker
+
+```bash
+# Build l'image
+docker build -t pmomusic:latest .
+
+# Le build prend environ 10-15 minutes selon votre machine
+```
+
+### Option 2 : Build avec docker-compose
+
+```bash
+# Build et démarre le conteneur
+docker-compose up --build
+
+# Ou juste build
+docker-compose build
+```
+
+### Build optimisé avec cache
+
+Pour accélérer les builds successifs, Docker réutilise les couches en cache :
+
+```bash
+# Build avec cache
+docker build -t pmomusic:latest .
+
+# Build sans cache (force rebuild complet)
+docker build --no-cache -t pmomusic:latest .
+```
+
+## Exécution du conteneur
+
+### Option 1 : Avec docker-compose (recommandé)
+
+```bash
+# Démarrer en arrière-plan
+docker-compose up -d
+
+# Voir les logs
+docker-compose logs -f
+
+# Arrêter
+docker-compose down
+
+# Redémarrer
+docker-compose restart
+```
+
+### Option 2 : Avec docker run
+
+```bash
+# Run en mode interactif
+docker run -it --rm \
+  --name pmomusic \
+  --network host \
+  -v $(pwd)/config:/home/pmomusic/.pmomusic \
+  -v $(pwd)/cache:/home/pmomusic/cache \
+  pmomusic:latest
+
+# Run en mode détaché
+docker run -d \
+  --name pmomusic \
+  --network host \
+  --restart unless-stopped \
+  -v $(pwd)/config:/home/pmomusic/.pmomusic \
+  -v $(pwd)/cache:/home/pmomusic/cache \
+  pmomusic:latest
+```
+
+## Configuration
+
+### Ports
+
+Par défaut, PMOMusic écoute sur le port **8080**. Vous pouvez modifier cela :
+
+- Dans `docker-compose.yml` : modifier la section `ports`
+- Avec `docker run` : utiliser `-p 8080:8080`
+
+### Volumes
+
+Deux volumes sont recommandés pour la persistance :
+
+- **Configuration** : `/home/pmomusic/.pmomusic` - Fichiers de configuration
+- **Cache** : `/home/pmomusic/cache` - Cache audio et métadonnées
+
+### Variables d'environnement
+
+Configurable via `docker-compose.yml` ou `-e` avec `docker run` :
+
+```bash
+# Niveau de logs Rust
+RUST_LOG=debug
+
+# Autres variables (selon votre configuration)
+# ...
+```
+
+### Réseau
+
+Pour UPnP/DLNA, utilisez **network_mode: host** pour permettre :
+- La découverte multicast
+- La communication avec les devices UPnP sur le réseau local
+
+**Note** : Le mode `host` ne fonctionne que sur Linux. Sur macOS/Windows avec Docker Desktop, utilisez le mapping de ports standard.
+
+## Gestion de l'image
+
+### Taille de l'image
+
+```bash
+# Voir la taille de l'image
+docker images pmomusic:latest
+
+# Résultat attendu : ~200-300MB
+```
+
+### Nettoyage
+
+```bash
+# Supprimer l'image
+docker rmi pmomusic:latest
+
+# Nettoyer les images de build intermédiaires
+docker builder prune
+
+# Nettoyer tous les caches Docker (libère beaucoup d'espace)
+docker system prune -a
+```
+
+## Build multi-plateforme
+
+Pour builder pour différentes architectures (ARM64, AMD64) :
+
+```bash
+# Créer un builder multi-plateforme
+docker buildx create --name multiarch --use
+
+# Build pour AMD64 et ARM64
+docker buildx build \
+  --platform linux/amd64,linux/arm64 \
+  -t pmomusic:latest \
+  --push \
+  .
+
+# Note : nécessite un registry Docker (Docker Hub, GHCR, etc.)
+```
+
+## Déploiement en production
+
+### 1. Avec docker-compose (simple)
+
+```bash
+# Sur le serveur de production
+git clone <votre-repo>
+cd pmomusic
+docker-compose up -d
+```
+
+### 2. Avec un registry Docker (recommandé)
+
+```bash
+# Sur votre machine de dev
+docker build -t yourregistry.com/pmomusic:v1.0.0 .
+docker push yourregistry.com/pmomusic:v1.0.0
+
+# Sur le serveur de production
+docker pull yourregistry.com/pmomusic:v1.0.0
+docker run -d ... yourregistry.com/pmomusic:v1.0.0
+```
+
+### 3. Avec un orchestrateur (Kubernetes, Docker Swarm)
+
+Créer un fichier de déploiement approprié selon votre orchestrateur.
+
+## Debugging
+
+### Logs du conteneur
+
+```bash
+# Logs en temps réel
+docker logs -f pmomusic
+
+# Logs avec docker-compose
+docker-compose logs -f
+```
+
+### Entrer dans le conteneur
+
+```bash
+# Shell interactif (bash n'est pas disponible, utiliser sh)
+docker exec -it pmomusic sh
+
+# Vérifier les processus
+docker exec -it pmomusic ps aux
+
+# Vérifier les fichiers
+docker exec -it pmomusic ls -la /home/pmomusic
+```
+
+### Health check
+
+Le conteneur inclut un health check. Vérifier l'état :
+
+```bash
+# Voir l'état de santé
+docker inspect --format='{{.State.Health.Status}}' pmomusic
+```
+
+## Troubleshooting
+
+### Le build échoue
+
+1. **Erreur de dépendances npm** :
+   - Vérifier que `pmoapp/webapp/package.json` est correct
+   - Essayer `docker build --no-cache`
+
+2. **Erreur de compilation Rust** :
+   - Vérifier que tous les fichiers Cargo.toml sont présents
+   - Vérifier les dépendances système (libsoxr, libasound2)
+
+3. **Out of memory** :
+   - Augmenter la mémoire allouée à Docker Desktop (settings)
+   - Utiliser `--memory` pour limiter la mémoire du build
+
+### Le conteneur ne démarre pas
+
+1. **Port déjà utilisé** :
+   ```bash
+   # Vérifier quel processus utilise le port 8080
+   sudo lsof -i :8080
+   ```
+
+2. **Permissions** :
+   - Vérifier les permissions des volumes montés
+   - Le conteneur s'exécute en tant qu'utilisateur `pmomusic` (UID 1000)
+
+3. **Configuration manquante** :
+   - Créer les répertoires de configuration avant de démarrer :
+     ```bash
+     mkdir -p config cache
+     ```
+
+### UPnP ne fonctionne pas
+
+1. **Network mode** :
+   - Sur Linux : utiliser `network_mode: host`
+   - Sur macOS/Windows : UPnP peut ne pas fonctionner correctement avec Docker Desktop
+
+2. **Firewall** :
+   - Vérifier que les ports UPnP ne sont pas bloqués
+   - Autoriser le multicast sur le réseau
+
+## Performance
+
+### Optimisations du build
+
+1. **Build cache** : Docker réutilise les couches en cache
+2. **Multi-stage build** : Réduit la taille de l'image finale
+3. **Strip des symboles** : Le binaire est strippé pour réduire sa taille
+
+### Optimisations runtime
+
+1. **Resource limits** : Définir des limites CPU/mémoire dans docker-compose.yml
+2. **Volumes** : Utiliser des volumes pour les données persistantes
+3. **Logs** : Configurer la rotation des logs Docker
+
+## Sécurité
+
+- ✅ Exécution en tant qu'utilisateur non-root
+- ✅ Image minimale (surface d'attaque réduite)
+- ✅ Pas de secrets dans l'image
+- ✅ Health checks activés
+- ✅ Certificats CA inclus pour HTTPS
+
+## Références
+
+- [Dockerfile](./Dockerfile)
+- [docker-compose.yml](./docker-compose.yml)
+- [.dockerignore](./.dockerignore)
+- [Documentation Rust](./Readme.md)

Dockerfile

@@ -0,0 +1,117 @@
+# ===================================
+# Stage 1: Build Vue.js webapp
+# ===================================
+FROM node:22-alpine AS webapp-builder
+
+WORKDIR /webapp
+
+# Copy webapp package files
+COPY pmoapp/webapp/package*.json ./
+
+# Install dependencies
+RUN npm ci --production=false
+
+# Copy webapp source
+COPY pmoapp/webapp/ ./
+
+# Build the webapp
+RUN npm run build
+
+# ===================================
+# Stage 2: Build Rust binary
+# ===================================
+FROM rustlang/rust:nightly-bookworm AS rust-builder
+
+WORKDIR /build
+
+# Install system dependencies for building
+RUN apt-get update && apt-get install -y \
+    libsoxr-dev \
+    libasound2-dev \
+    pkg-config \
+    cmake \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy Cargo workspace files
+COPY Cargo.toml Cargo.lock ./
+
+# Copy all crates
+COPY PMOMusic/ ./PMOMusic/
+COPY pmoupnp/ ./pmoupnp/
+COPY pmomediarenderer/ ./pmomediarenderer/
+COPY pmomediaserver/ ./pmomediaserver/
+COPY pmoconfig/ ./pmoconfig/
+COPY pmoutils/ ./pmoutils/
+COPY pmodidl/ ./pmodidl/
+COPY pmoserver/ ./pmoserver/
+COPY pmocache/ ./pmocache/
+COPY pmocovers/ ./pmocovers/
+COPY pmoaudiocache/ ./pmoaudiocache/
+COPY pmoaudio/ ./pmoaudio/
+COPY pmoqobuz/ ./pmoqobuz/
+COPY pmoparadise/ ./pmoparadise/
+COPY pmosource/ ./pmosource/
+COPY pmoplaylist/ ./pmoplaylist/
+COPY pmoflac/ ./pmoflac/
+COPY pmometadata/ ./pmometadata/
+COPY pmocontrol/ ./pmocontrol/
+COPY pmoaudio-ext/ ./pmoaudio-ext/
+COPY pmoapp/ ./pmoapp/
+
+# Copy the webapp dist from previous stage
+COPY --from=webapp-builder /webapp/dist ./pmoapp/webapp/dist/
+
+# Build the Rust binary in release mode
+RUN cargo build --release --bin PMOMusic
+
+# Strip debug symbols to reduce binary size
+RUN strip /build/target/release/PMOMusic
+
+# ===================================
+# Stage 3: Minimal runtime image
+# ===================================
+FROM debian:bookworm-slim
+
+ARG BUILD_DATE
+LABEL org.opencontainers.image.created=$BUILD_DATE
+LABEL org.opencontainers.image.title="PMOMusic UPNP Music Server"
+LABEL org.opencontainers.image.version="0.1"
+LABEL org.opencontainers.image.authors="eric@coissac.eu"
+LABEL org.opencontainers.image.licenses="CeCILL-2.0"
+LABEL org.opencontainers.image.url="https://gargoton.petite-maison-orange.fr/eric/pmomusic"
+LABEL org.opencontainers.image.description="PMOMusic est une application Rust proposant en un binaire unique une Serveur de Musique, et une point de controle UPNP controlable via une application web."
+
+# Install only runtime dependencies
+RUN apt-get update && apt-get install -y \
+    libsoxr0 \
+    libasound2 \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN useradd -m -u 1000 pmomusic
+
+# Copy the binary from builder
+COPY --from=rust-builder /build/target/release/PMOMusic /usr/local/bin/PMOMusic
+
+# Set ownership
+RUN chown pmomusic:pmomusic /usr/local/bin/PMOMusic
+
+# Switch to non-root user
+USER pmomusic
+
+# Create directories for configuration and cache
+RUN mkdir -p /home/pmomusic/.pmomusic
+
+# Set working directory
+WORKDIR /home/pmomusic
+
+# Expose default port (adjust if needed)
+EXPOSE 8080
+
+# Health check (adjust the URL if needed)
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD ["/usr/local/bin/PMOMusic", "--help"] || exit 1
+
+# Run the binary
+ENTRYPOINT ["/usr/local/bin/PMOMusic"]

INSTALL_LIBSOXR.md

@@ -0,0 +1,296 @@
+# Installation des dépendances système sans droits sudo
+
+Ce document explique comment installer les dépendances système de `pmoaudio` localement sans privilèges administrateur.
+
+## Dépendances requises
+
+1. **libsoxr** - Nécessaire pour `ResamplingNode` (resampling audio haute qualité)
+2. **libasound2** (ALSA) - Nécessaire pour `AudioSink` via cpal (lecture audio sur Linux)
+
+## Contexte
+
+Les crates `soxr` et `cpal` nécessitent des bibliothèques système. Dans un environnement sans droits sudo (comme Claude Code), voici comment les installer localement.
+
+## Méthode : Installation locale via apt-get download
+
+### 1. Télécharger les packages .deb
+
+```bash
+cd ~/.local
+
+# Pour libsoxr (ResamplingNode)
+apt-get download libsoxr-dev libsoxr0
+
+# Pour ALSA (AudioSink)
+# Note: libasound2t64 contient la bibliothèque partagée, libasound2-dev les headers
+apt-get download libasound2-dev libasound2t64
+```
+
+Cela télécharge les fichiers `.deb` sans les installer système-wide.
+
+### 2. Extraire les packages
+
+```bash
+# Extraire libsoxr
+dpkg -x libsoxr-dev_*.deb .
+dpkg -x libsoxr0_*.deb .
+
+# Extraire ALSA
+dpkg -x libasound2-dev_*.deb .
+dpkg -x libasound2t64_*.deb .
+```
+
+Les fichiers sont extraits dans `~/.local/usr/lib/x86_64-linux-gnu/` et `~/.local/usr/include/`.
+
+### 3. Configurer les variables d'environnement
+
+Ajouter à votre `~/.bashrc` ou exporter dans votre session :
+
+```bash
+export PKG_CONFIG_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH"
+export LD_LIBRARY_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+export RUSTFLAGS="-L $HOME/.local/usr/lib/x86_64-linux-gnu"
+```
+
+**IMPORTANT:** Ces variables doivent être définies dans chaque session où vous compilez le projet.
+
+### 4. Vérifier l'installation
+
+```bash
+# Vérifier libsoxr
+pkg-config --libs --cflags soxr
+
+# Vérifier ALSA
+pkg-config --libs --cflags alsa
+```
+
+Devrait retourner quelque chose comme :
+```
+# soxr
+-I/root/.local/usr/include -L/root/.local/usr/lib/x86_64-linux-gnu -lsoxr
+
+# alsa
+-I/root/.local/usr/include -L/root/.local/usr/lib/x86_64-linux-gnu -lasound
+```
+
+## Utilisation avec Cargo
+
+### Pour les builds réguliers
+
+Les variables d'environnement suffisent pour `cargo build` et `cargo run`.
+
+### Pour les tests
+
+Les tests nécessitent également la configuration du linker. Deux options :
+
+#### Option A : Configuration locale du projet (NON RECOMMANDÉ pour le versioning)
+
+Créer `.cargo/config.toml` dans chaque crate :
+
+```toml
+[build]
+rustflags = ["-L", "/root/.local/usr/lib/x86_64-linux-gnu"]
+```
+
+**⚠️ NE PAS committer ces fichiers** - ils contiennent des chemins spécifiques à votre installation.
+
+#### Option B : Variables d'environnement pour cargo test
+
+```bash
+export PKG_CONFIG_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH"
+export LD_LIBRARY_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+cargo test
+```
+
+## Pour d'autres distributions
+
+### macOS (avec Homebrew)
+
+```bash
+brew install libsoxr
+# Note: ALSA n'est pas nécessaire sur macOS (rodio utilise CoreAudio)
+```
+
+### Debian/Ubuntu (avec sudo)
+
+```bash
+sudo apt-get install libsoxr-dev libasound2-dev
+```
+
+### Fedora/RHEL
+
+```bash
+sudo dnf install soxr-devel
+```
+
+## Troubleshooting
+
+### Erreur : "Package 'soxr' was not found" ou "Package 'alsa' was not found"
+
+- Vérifier que `PKG_CONFIG_PATH` contient le bon chemin
+- Vérifier que les fichiers `soxr.pc` et `alsa.pc` existent dans ce répertoire
+
+### Erreur de link : "unable to find library -lsoxr" ou "-lasound"
+
+- Pour `cargo build` : vérifier `LD_LIBRARY_PATH`
+- Pour `cargo test` : utiliser la configuration rustflags (Option A ci-dessus)
+
+### Le test compile mais échoue au runtime
+
+```
+error while loading shared libraries: libsoxr.so.0: cannot open shared object file
+```
+
+Solution : Ajouter `LD_LIBRARY_PATH` également pour l'exécution :
+
+```bash
+export LD_LIBRARY_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+cargo test
+```
+
+## Guide complet pour environnement Claude Code
+
+### Configuration initiale (à faire une seule fois)
+
+Dans une session Claude Code (https://claude.ai/code), vous n'avez pas de droits sudo.
+
+**🚀 Méthode rapide (recommandée) :**
+
+```bash
+# 1. Installation automatique des dépendances (une seule fois)
+./setup-deps.sh
+
+# 2. Configuration des variables d'environnement (à chaque session)
+source setup-env.sh
+
+# 3. Compilation
+cargo build
+```
+
+**📋 Méthode manuelle (si les scripts ne fonctionnent pas) :**
+
+#### 1. Installation des dépendances
+
+```bash
+# Créer le répertoire local
+mkdir -p ~/.local
+cd ~/.local
+
+# Télécharger tous les packages nécessaires
+apt-get download libsoxr-dev libsoxr0 libasound2-dev libasound2t64
+
+# Extraire tous les packages
+dpkg -x libsoxr-dev_*.deb .
+dpkg -x libsoxr0_*.deb .
+dpkg -x libasound2-dev_*.deb .
+dpkg -x libasound2t64_*.deb .
+
+# Retourner au projet
+cd /home/user/pmomusic
+```
+
+#### 2. Configuration des variables d'environnement
+
+**IMPORTANT:** Ces variables doivent être exportées dans CHAQUE session Claude Code avant de compiler :
+
+```bash
+export PKG_CONFIG_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH"
+export LD_LIBRARY_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+export RUSTFLAGS="-L $HOME/.local/usr/lib/x86_64-linux-gnu"
+```
+
+**Astuce :** Créez un fichier `setup-env.sh` pour ne pas avoir à retaper ces commandes à chaque session :
+
+```bash
+cat > setup-env.sh << 'EOF'
+#!/bin/bash
+# Script de configuration des variables d'environnement pour PMOMusic
+# Usage: source setup-env.sh
+
+# Configuration des chemins pour libsoxr et libasound2
+export PKG_CONFIG_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH"
+export LD_LIBRARY_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+export RUSTFLAGS="-L $HOME/.local/usr/lib/x86_64-linux-gnu"
+
+echo "Variables d'environnement configurées pour PMOMusic"
+echo "  PKG_CONFIG_PATH=$PKG_CONFIG_PATH"
+echo "  LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
+echo "  RUSTFLAGS=$RUSTFLAGS"
+echo ""
+echo "Vous pouvez maintenant compiler avec: cargo build"
+EOF
+
+chmod +x setup-env.sh
+```
+
+Puis dans chaque session :
+
+```bash
+source setup-env.sh
+```
+
+⚠️ **Note :** Le fichier `setup-env.sh` est dans `.gitignore` (configuration locale), vous devez le créer vous-même avec le contenu ci-dessus.
+
+#### 3. Vérifier l'installation
+
+```bash
+# Vérifier que pkg-config trouve les bibliothèques
+pkg-config --libs --cflags soxr
+pkg-config --libs --cflags alsa
+
+# Devrait afficher quelque chose comme :
+# -I/root/.local/usr/include -L/root/.local/usr/lib/x86_64-linux-gnu -lsoxr
+# -I/root/.local/usr/include -L/root/.local/usr/lib/x86_64-linux-gnu -lasound
+```
+
+#### 4. Compiler et tester
+
+```bash
+# Compiler le workspace complet
+cargo build
+
+# Tester l'exemple play_and_cache de pmoparadise
+cargo run --package pmoparadise --example play_and_cache --features full -- 0
+```
+
+### Workflow pour chaque nouvelle session
+
+À chaque fois que vous démarrez une nouvelle session Claude Code :
+
+```bash
+# 1. Configuration de l'environnement
+source setup-env.sh
+
+# 2. Compilation
+cargo build
+
+# 3. Exécution des exemples
+cargo run --package pmoparadise --example play_and_cache --features full -- 0
+```
+
+**IMPORTANT :** Si vous oubliez d'exporter les variables, vous obtiendrez des erreurs comme :
+```
+error: failed to run custom build command for `soxr-sys`
+Package 'soxr' was not found in the pkg-config search path
+```
+
+ou
+
+```
+rust-lld: error: unable to find library -lasound
+```
+
+**Solution :** Exécutez `source setup-env.sh` et recompilez.
+
+### Notes importantes
+
+- ✅ Les dépendances installées dans `~/.local` persistent entre les sessions
+- ✅ Les variables d'environnement doivent être réexportées à chaque nouvelle session
+- ❌ NE JAMAIS créer de fichiers `.cargo/config.toml` dans le projet (chemins spécifiques)
+- ❌ NE JAMAIS committer `setup-env.sh` (configuration locale)
+- 💡 Sur macOS (via Homebrew) : seul `libsoxr` est nécessaire (pas d'ALSA)
+
+## Références
+
+- libsoxr GitHub: https://github.com/chirlu/soxr
+- Documentation pkg-config: https://www.freedesktop.org/wiki/Software/pkg-config/

INSTALL_NOTES.md

@@ -0,0 +1,89 @@
+# Notes d'installation pour PMOMusic
+
+## Prérequis système
+
+### libsoxr (obligatoire pour pmoaudio - resampling)
+
+La bibliothèque `libsoxr` est requise pour le resampling audio dans `pmoaudio`.
+
+### libasound2/ALSA (obligatoire pour pmoaudio - lecture audio sur Linux)
+
+La bibliothèque ALSA est requise pour `AudioSink` via `cpal` sur Linux. Sur macOS et Windows, aucune dépendance externe n'est nécessaire (CoreAudio et WASAPI sont utilisés).
+
+**Installation** :
+
+```bash
+# Debian/Ubuntu
+sudo apt-get install libsoxr-dev libasound2-dev
+
+# Fedora/RHEL
+sudo dnf install libsoxr-devel alsa-lib-devel
+
+# Arch Linux
+sudo pacman -S libsoxr alsa-lib
+
+# macOS (Homebrew) - ALSA non nécessaire sur macOS
+brew install libsoxr
+
+# Alpine Linux
+apk add soxr-dev alsa-lib-dev
+```
+
+**Sans privilèges root (Claude Code, environnements sans sudo)** :
+
+🚀 **Installation automatique** :
+
+```bash
+# 1. Installation des dépendances (une seule fois)
+./setup-deps.sh
+
+# 2. Configuration de l'environnement (à chaque session)
+source setup-env.sh
+
+# 3. Compilation
+cargo build
+```
+
+Pour plus de détails, consultez `INSTALL_LIBSOXR.md`.
+
+---
+
+## Nouveaux composants
+
+### PlaylistSource (pmoaudio-ext)
+
+Source audio qui lit une playlist `pmoplaylist` et diffuse les pistes en continu.
+
+**Feature** : `playlist`
+
+```bash
+# Compiler avec la feature playlist
+cargo build --package pmoaudio-ext --features playlist
+```
+
+**⚠️ Important** : Cette source émet du PCM avec sample_rate et bit_depth **variables**. Pour un flux homogène, ajoutez dans le pipeline :
+- `ResamplingNode` (normalise le sample_rate)
+- `ToI24Node` / `ToI16Node` (normalise la profondeur de bits)
+
+### ResamplingNode (pmoaudio)
+
+Nœud générique qui normalise le sample_rate vers une valeur cible fixe.
+
+**Usage** :
+```rust
+let mut resampler = ResamplingNode::new(48000); // Force 48kHz
+```
+
+---
+
+## Compilation
+
+```bash
+# Compiler tout le workspace (nécessite libsoxr)
+cargo build
+
+# Compiler sans pmoaudio (si libsoxr manque)
+cargo build --package pmoplaylist
+cargo build --package pmoaudiocache
+# etc.
+```

Makefile

@@ -1,6 +1,8 @@
 # Makefile pour projet Rust + Vue.js
 # Variables de configuration
 CARGO = cargo
+CARGO_NIGHTLY = rustup run nightly cargo
+FEATURES ?=
 NPM = npm
 WEBAPP_DIR = pmoapp/webapp
 DIST_DIR = $(WEBAPP_DIR)/dist
@@ -14,7 +16,9 @@ YELLOW = \033[1;33m
 RED = \033[0;31m
 NC = \033[0m # No Color
 
-.PHONY: all help build release debug test doc webapp clean install dev check fmt clippy watch
+.DEFAULT_GOAL := simd
+
+.PHONY: all help build release debug test doc webapp clean install dev check fmt clippy watch simd scalar
 
 # Cible par défaut
 all: build
@@ -31,13 +35,13 @@ build: webapp release
 ## release: Compile le binaire Rust en mode release
 release: webapp
 	@echo "$(YELLOW)→ Compilation Rust (release)...$(NC)"
-	$(CARGO) build --release
+	$(CARGO) build --release $(FEATURES)
 	@echo "$(GREEN)✓ Binaire disponible : $(RUST_TARGET)/$(BINARY_NAME)$(NC)"
 
 ## debug: Compile le binaire Rust en mode debug
 debug: webapp
 	@echo "$(YELLOW)→ Compilation Rust (debug)...$(NC)"
-	$(CARGO) build
+	$(CARGO) build $(FEATURES)
 	@echo "$(GREEN)✓ Binaire disponible : target/debug/$(BINARY_NAME)$(NC)"
 
 ## test: Exécute tous les tests Rust
@@ -46,6 +50,18 @@ test:
 	$(CARGO) test --all
 	@echo "$(GREEN)✓ Tests terminés$(NC)"
 
+## simd: Compile l'application en mode SIMD (nightly requis)
+simd:
+	@echo "$(YELLOW)→ Build SIMD (nightly)...$(NC)"
+	$(MAKE) release CARGO="$(CARGO_NIGHTLY)" FEATURES="--features simd"
+	@echo "$(GREEN)✓ Build SIMD terminé$(NC)"
+
+## scalar: Compile l'application en mode scalaire
+scalar:
+	@echo "$(YELLOW)→ Build scalaire...$(NC)"
+	$(MAKE) release FEATURES=""
+	@echo "$(GREEN)✓ Build scalaire terminé$(NC)"
+
 ## test-doc: Teste les exemples dans la documentation
 test-doc:
 	@echo "$(YELLOW)→ Test des exemples de documentation...$(NC)"
@@ -187,4 +203,4 @@ coverage:
 	@echo "$(YELLOW)→ Génération du rapport de couverture...$(NC)"
 	$(CARGO) tarpaulin --out Html --output-dir target/coverage
 	@echo "$(GREEN)✓ Rapport disponible dans target/coverage/index.html$(NC)"
-	
+	

OPTIMIZATION_PREBUFFER_TO_PLAYLIST.md

@@ -0,0 +1,485 @@
+# Optimisation: Réduction du délai prebuffer → playlist (19s → 1s)
+
+## Contexte
+
+Le système de progressive caching fonctionne correctement, mais il y a un délai non optimal entre le moment où le prebuffer est atteint et le moment où la track est ajoutée à la playlist.
+
+### État actuel (branche `claude/fix-play-and-cache-streaming-011CUsMBxH4fsgoadgkiPdoK`)
+
+**Timing mesuré:**
+```
+t=0.6s   : Prebuffer complete (512KB téléchargés) ✅
+t=19.2s  : tokio::join!() complete (pump_future finit)
+t=19.2s  : Track added to playlist
+t=19.7s  : Playback starts
+```
+
+**Délai total: ~19 secondes**
+
+### Code actuel problématique
+
+Location: `pmoaudio-ext/src/sinks/flac_cache_sink.rs:167-178`
+
+```rust
+// Exécuter pump et add_from_reader en parallèle
+let pump_future = pump_track_segments(
+    first_segment,
+    &mut rx,      // ← emprunte muablement rx
+    pcm_tx,
+    bits_per_sample,
+    sample_rate,
+    &stop_token,
+);
+
+// Attendre les deux tâches en parallèle
+let (cache_result, pump_result) = tokio::join!(cache_future, pump_future);
+
+let pk = cache_result.map_err(|e| {
+    AudioError::ProcessingError(format!("Failed to add to cache: {}", e))
+})?;
+
+let (_chunks, _samples, _duration_sec, stop_reason) = pump_result?;
+```
+
+**Le problème:** `tokio::join!()` attend que **LES DEUX** futures se terminent:
+- `cache_future` retourne après prebuffer (~0.6s) ✅
+- `pump_future` lit **toute** la première track du RadioParadiseStreamSource (~19s) ⏱️
+
+Donc même si le prebuffer est atteint en 0.6s, on attend 19s avant de push à la playlist!
+
+## Objectif
+
+Réduire le délai à **~1 seconde** en pushant à la playlist **immédiatement après le prebuffer**, sans attendre que `pump_future` se termine.
+
+**Timing visé:**
+```
+t=0.6s   : Prebuffer complete ✅
+t=0.7s   : Track added to playlist ← IMMÉDIAT!
+t=1.2s   : Playback starts ← ~1 seconde!
+t=19.2s  : pump_future finit en arrière-plan
+```
+
+## Contraintes techniques
+
+### 1. Problème du borrow checker
+
+`pump_future` emprunte muablement `rx`:
+```rust
+async fn pump_track_segments(
+    first_segment: Arc<AudioSegment>,
+    rx: &mut mpsc::Receiver<Arc<AudioSegment>>,  // ← &mut borrow
+    // ...
+)
+```
+
+On ne peut pas faire:
+```rust
+tokio::pin!(cache_future);
+tokio::pin!(pump_future);  // ← pump_future contient un &mut rx
+
+let pk = cache_future.await;  // cache_future termine
+
+// ❌ ERREUR: on a toujours un borrow mutable de rx dans pump_future
+// On ne peut pas continuer à utiliser rx (ou l'objet qui le contient)
+playlist_handle.push(pk.clone()).await;
+
+let result = pump_future.await;  // pump_future continue
+```
+
+Le borrow checker nous empêche d'attendre `cache_future` seul, puis de faire d'autres opérations, puis d'attendre `pump_future`, car `pump_future` garde un borrow mutable de `rx` pendant toute sa durée de vie.
+
+### 2. Contraintes de l'API
+
+- `pump_track_segments()` doit lire `rx` pour recevoir les segments du RadioParadiseStreamSource
+- Le FlacCacheSinkLogic doit garder ownership de `rx` pour traiter les tracks suivantes
+- `pump_future` ne peut pas être spawné dans un tokio::spawn car il retourne un `StopReason` nécessaire pour la logique métier
+
+## Solutions possibles
+
+### Solution A: Refactoriser pump_track_segments pour prendre ownership de rx
+
+**Approche:**
+1. Créer `pump_track_segments_owned` qui prend ownership de `rx`
+2. Cette fonction retourne `(result, rx)` - elle rend ownership de `rx`
+3. Spawner cette future dans tokio::spawn
+4. Attendre cache_future seul, push immédiatement
+5. Attendre la task spawnée plus tard
+
+**Signature:**
+```rust
+async fn pump_track_segments_owned(
+    first_segment: Arc<AudioSegment>,
+    rx: mpsc::Receiver<Arc<AudioSegment>>,  // ownership!
+    pcm_tx: mpsc::Sender<Vec<u8>>,
+    bits_per_sample: u8,
+    expected_rate: u32,
+    stop_token: CancellationToken,
+) -> Result<(u64, u64, f64, StopReason, mpsc::Receiver<Arc<AudioSegment>>), AudioError>
+//                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rend rx
+```
+
+**Utilisation:**
+```rust
+let pump_handle = tokio::spawn(pump_track_segments_owned(
+    first_segment,
+    rx,  // move ownership
+    pcm_tx,
+    bits_per_sample,
+    sample_rate,
+    stop_token.clone(),
+));
+
+// Attendre SEULEMENT le prebuffer
+let pk = cache_future.await?;
+
+// Push IMMÉDIATEMENT à la playlist
+#[cfg(feature = "playlist")]
+if let Some(ref playlist_handle) = self.playlist_handle {
+    playlist_handle.push(pk.clone()).await?;
+}
+
+// MAINTENANT attendre que pump finisse
+let (result, rx_returned) = pump_handle.await.unwrap()?;
+rx = rx_returned;  // récupérer rx pour la prochaine track
+```
+
+**Avantages:**
+- ✅ Pas de problème de borrow checker
+- ✅ Push immédiat après prebuffer
+- ✅ Délai réduit à ~1s
+
+**Inconvénients:**
+- ⚠️ Nécessite de modifier la signature de `pump_track_segments`
+- ⚠️ Plus complexe (ownership passé puis rendu)
+
+### Solution B: Utiliser un channel pour signaler le prebuffer
+
+**Approche:**
+1. Créer un oneshot channel `(prebuffer_tx, prebuffer_rx)`
+2. `cache_future` envoie le pk via `prebuffer_tx` dès le prebuffer atteint
+3. Le code principal attend `prebuffer_rx`, push immédiatement
+4. Puis attend `tokio::join!()` normalement
+
+**Code:**
+```rust
+let (prebuffer_tx, prebuffer_rx) = tokio::sync::oneshot::channel();
+
+let cache_future = async {
+    let pk = self.cache.add_from_reader(...).await?;
+    let _ = prebuffer_tx.send(pk.clone());  // Signal prebuffer!
+    Ok(pk)
+};
+
+let pump_future = pump_track_segments(...);
+
+// Spawner les deux en parallèle
+let cache_handle = tokio::spawn(cache_future);
+let pump_handle = tokio::spawn(pump_future);
+
+// Attendre SEULEMENT le signal de prebuffer
+let pk = prebuffer_rx.await.unwrap();
+
+// Push IMMÉDIATEMENT à la playlist
+playlist_handle.push(pk.clone()).await?;
+
+// Puis attendre que tout finisse
+let (cache_result, pump_result) = tokio::join!(cache_handle, pump_handle);
+```
+
+**Avantages:**
+- ✅ Pas besoin de changer les signatures
+- ✅ Push immédiat après prebuffer
+
+**Inconvénients:**
+- ⚠️ Nécessite de wrapper cache_future pour envoyer le signal
+- ⚠️ Ajoute un oneshot channel
+
+### Solution C: Modifier l'API du cache pour avoir un callback
+
+**Approche:**
+1. Ajouter un paramètre callback à `add_from_reader()`
+2. Le cache appelle ce callback dès le prebuffer atteint
+3. Le callback push à la playlist
+
+**Signature:**
+```rust
+pub async fn add_from_reader_with_callback<R, F>(
+    &self,
+    source_uri: Option<&str>,
+    reader: R,
+    length: Option<u64>,
+    collection: Option<&str>,
+    on_prebuffer: F,  // ← nouveau callback
+) -> Result<String>
+where
+    R: AsyncRead + Send + Unpin + 'static,
+    F: FnOnce(String) + Send + 'static,  // F reçoit le pk
+```
+
+**Avantages:**
+- ✅ API propre et réutilisable
+- ✅ Pas de problème de borrow checker
+
+**Inconvénients:**
+- ⚠️ Nécessite de modifier l'API du cache (impact sur autres parties du code)
+- ⚠️ Ajoute de la complexité à l'API
+
+## Recommandation
+
+**Je recommande la Solution A** (refactoriser `pump_track_segments_owned`):
+- Plus explicite et claire
+- Pas d'impact sur l'API du cache
+- Ownership bien défini (passage puis retour de rx)
+- Testable indépendamment
+
+## Plan d'implémentation
+
+### Étape 1: Créer pump_track_segments_owned
+
+Location: `pmoaudio-ext/src/sinks/flac_cache_sink.rs`
+
+```rust
+/// Pompe les segments pour une seule track (s'arrête au TrackBoundary).
+///
+/// Version qui prend ownership de rx pour permettre un await séparé du cache.
+/// Retourne rx à la fin pour permettre le traitement des tracks suivantes.
+async fn pump_track_segments_owned(
+    first_segment: Arc<AudioSegment>,
+    mut rx: mpsc::Receiver<Arc<AudioSegment>>,
+    pcm_tx: mpsc::Sender<Vec<u8>>,
+    bits_per_sample: u8,
+    expected_rate: u32,
+    stop_token: CancellationToken,
+) -> Result<(u64, u64, f64, StopReason, mpsc::Receiver<Arc<AudioSegment>>), AudioError> {
+    let mut chunks = 0u64;
+    let mut samples = 0u64;
+    let mut duration_sec = 0.0f64;
+
+    // Traiter le premier segment
+    if let Some(chunk) = first_segment.as_chunk() {
+        let pcm_bytes = chunk_to_pcm_bytes(chunk, bits_per_sample)?;
+        if !pcm_bytes.is_empty() {
+            if pcm_tx.send(pcm_bytes).await.is_err() {
+                drop(pcm_tx);
+                return Ok((chunks, samples, duration_sec, StopReason::ChannelClosed, rx));
+            }
+            chunks += 1;
+            samples += chunk.len() as u64;
+            duration_sec += chunk.len() as f64 / expected_rate as f64;
+        }
+    }
+
+    // Loop pour le reste des segments...
+    loop {
+        let segment = tokio::select! {
+            result = rx.recv() => {
+                match result {
+                    Some(seg) => seg,
+                    None => {
+                        drop(pcm_tx);
+                        return Ok((chunks, samples, duration_sec, StopReason::ChannelClosed, rx));
+                    }
+                }
+            }
+            _ = stop_token.cancelled() => {
+                drop(pcm_tx);
+                return Ok((chunks, samples, duration_sec, StopReason::ChannelClosed, rx));
+            }
+        };
+
+        match &segment.segment {
+            _AudioSegment::Chunk(chunk) => {
+                let pcm_bytes = chunk_to_pcm_bytes(chunk, bits_per_sample)?;
+                if !pcm_bytes.is_empty() {
+                    if pcm_tx.send(pcm_bytes).await.is_err() {
+                        drop(pcm_tx);
+                        return Ok((chunks, samples, duration_sec, StopReason::ChannelClosed, rx));
+                    }
+                    chunks += 1;
+                    samples += chunk.len() as u64;
+                    duration_sec += chunk.len() as f64 / expected_rate as f64;
+                }
+            }
+            _AudioSegment::Sync(marker) => match &**marker {
+                SyncMarker::TrackBoundary { metadata, .. } => {
+                    drop(pcm_tx);
+                    return Ok((chunks, samples, duration_sec, StopReason::TrackBoundary(metadata.clone()), rx));
+                }
+                SyncMarker::EndOfStream => {
+                    drop(pcm_tx);
+                    return Ok((chunks, samples, duration_sec, StopReason::EndOfStream, rx));
+                }
+                _ => continue,
+            },
+        }
+    }
+}
+```
+
+### Étape 2: Modifier FlacCacheSinkLogic::process
+
+Location: `pmoaudio-ext/src/sinks/flac_cache_sink.rs:~167`
+
+```rust
+let collection_ref = self.collection.as_deref();
+let cache_future = self.cache.add_from_reader(
+    None,
+    flac_stream,
+    None,
+    collection_ref,
+);
+
+// Spawner pump_future avec ownership de rx
+let pump_handle = tokio::spawn(pump_track_segments_owned(
+    first_segment,
+    rx,  // move ownership!
+    pcm_tx,
+    bits_per_sample,
+    sample_rate,
+    stop_token.clone(),
+));
+
+// Attendre SEULEMENT le prebuffer (cache retourne après 512KB)
+tracing::debug!("FlacCacheSink: Waiting for cache prebuffer to complete");
+let pk = cache_future.await.map_err(|e| {
+    AudioError::ProcessingError(format!("Failed to add to cache: {}", e))
+})?;
+
+tracing::debug!("FlacCacheSink: Prebuffer complete with pk {}, pushing to playlist NOW", pk);
+
+// Copier les métadonnées AVANT push
+if let Some(src_metadata) = track_metadata.clone() {
+    let dest_metadata = self.cache.track_metadata(&pk);
+    pmometadata::copy_metadata_into(&src_metadata, &dest_metadata)
+        .await
+        .map_err(|e| {
+            AudioError::ProcessingError(format!("Failed to copy metadata to cache: {}", e))
+        })?;
+}
+
+// Push IMMÉDIATEMENT à la playlist (après prebuffer, avant pump complet!)
+#[cfg(feature = "playlist")]
+if let Some(ref playlist_handle) = self.playlist_handle {
+    tracing::debug!("FlacCacheSink: Pushing pk {} to playlist", pk);
+    playlist_handle.push(pk.clone()).await.map_err(|e| {
+        AudioError::ProcessingError(format!("Failed to add to playlist: {}", e))
+    })?;
+    tracing::debug!("FlacCacheSink: Successfully pushed to playlist");
+}
+
+// MAINTENANT attendre que pump finisse (il continue en arrière-plan)
+tracing::debug!("FlacCacheSink: Waiting for pump to complete");
+let pump_result = pump_handle.await.map_err(|e| {
+    AudioError::ProcessingError(format!("Pump task panicked: {}", e))
+})?;
+
+let (_chunks, _samples, _duration_sec, stop_reason, rx_returned) = pump_result?;
+rx = rx_returned;  // récupérer rx pour la prochaine track
+tracing::debug!("FlacCacheSink: Pump completed");
+
+// Continuer avec download des covers en arrière-plan...
+```
+
+### Étape 3: Tester
+
+```bash
+# Nettoyer et rebuild
+rm -rf /tmp/pmomusic_test
+source setup-env.sh
+cargo build --example play_and_cache --features full
+
+# Tester avec logs de timing
+RUST_LOG=debug target/debug/examples/play_and_cache 0 --null-audio 2>&1 | \
+  grep -E "Prebuffer complete|Pushing pk.*to playlist|popped track" | \
+  head -20
+```
+
+**Résultats attendus:**
+```
+[TIME_A] FlacCacheSink: Prebuffer complete with pk XXX, pushing to playlist NOW
+[TIME_B] FlacCacheSink: Successfully pushed to playlist
+[TIME_C] PlaylistSourceLogic: popped track from playlist
+
+Délai (TIME_C - TIME_A) devrait être < 1 seconde!
+```
+
+### Étape 4: Valider le comportement
+
+Vérifier que:
+1. ✅ Le prebuffer est atteint rapidement (~0.6s)
+2. ✅ Le push à la playlist est immédiat (~0.1s après prebuffer)
+3. ✅ La lecture démarre rapidement (~1s total)
+4. ✅ Toutes les tracks se suivent correctement
+5. ✅ Les completion markers sont créés
+6. ✅ Les tracks suivantes fonctionnent (rx est bien récupéré)
+7. ✅ Pas de panic ou deadlock
+
+## Debugging
+
+### Si le borrow checker proteste
+
+Vérifier que:
+- `pump_track_segments_owned` prend bien ownership de `rx` (pas `&mut`)
+- `rx` est bien retourné dans le tuple de retour
+- `rx = rx_returned;` récupère bien ownership après await
+
+### Si les tracks suivantes ne fonctionnent pas
+
+Vérifier que:
+- `rx` est bien réassigné après le pump: `rx = rx_returned;`
+- La loop dans `process()` continue correctement avec le nouveau `rx`
+
+### Si le timing n'est pas amélioré
+
+Ajouter des logs avec timestamps:
+```rust
+let start = std::time::Instant::now();
+let pk = cache_future.await?;
+tracing::info!("Prebuffer took {:?}", start.elapsed());
+
+let start2 = std::time::Instant::now();
+playlist_handle.push(pk.clone()).await?;
+tracing::info!("Playlist push took {:?}", start2.elapsed());
+```
+
+## Fichiers à modifier
+
+1. **pmoaudio-ext/src/sinks/flac_cache_sink.rs**
+   - Ajouter `pump_track_segments_owned()` (~ligne 432)
+   - Modifier `FlacCacheSinkLogic::process()` (~ligne 167)
+
+## Tests de régression
+
+Après l'implémentation, tester:
+
+```bash
+# Test 1: Premier download (cache vide)
+rm -rf /tmp/pmomusic_test
+target/debug/examples/play_and_cache 0 --null-audio
+
+# Test 2: Deuxième download (fichier déjà en cache)
+# Ne pas supprimer /tmp/pmomusic_test
+target/debug/examples/play_and_cache 0 --null-audio
+
+# Test 3: Download interrompu (Ctrl+C)
+target/debug/examples/play_and_cache 0 --null-audio
+# Appuyer Ctrl+C après 2 secondes
+
+# Test 4: Plusieurs tracks consécutives
+# Laisser tourner 1 minute pour voir plusieurs tracks
+timeout 60 target/debug/examples/play_and_cache 0 --null-audio
+```
+
+## Métriques de succès
+
+- ✅ Délai prebuffer → playlist: **< 1 seconde** (actuellement ~19s)
+- ✅ Délai prebuffer → lecture: **< 2 secondes** (actuellement ~19.5s)
+- ✅ Pas de régression fonctionnelle
+- ✅ Toutes les tracks se suivent correctement
+- ✅ Les completion markers sont créés
+
+## Références
+
+- Branche actuelle: `claude/fix-play-and-cache-streaming-011CUsMBxH4fsgoadgkiPdoK`
+- Code de référence: commit `ed0bbfb` (Add FlacCacheSink debug logs - system now works!)
+- Issue originale: "play_and_cache n'a pas le comportement souhaité"

PLAYER_PMOSOURCE_README.md

@@ -0,0 +1,285 @@
+# Player Générique PMO Music
+
+## Vue d'ensemble
+
+Ce document décrit l'implémentation d'un nouveau player web générique qui utilise **uniquement** l'API du trait `pmosource` sans dépendre d'aucune implémentation spécifique (comme `pmoparadise`).
+
+## Objectifs
+
+L'objectif principal est de **tester l'API `pmosource` dans un cas d'application concret** afin d'identifier ce qui manque ou pourrait être amélioré dans l'API générique.
+
+## Architecture
+
+### 1. Service API TypeScript (`pmoapp/webapp/src/services/pmosource.ts`)
+
+Service qui encapsule toutes les interactions avec l'API REST de pmosource :
+
+```typescript
+// Endpoints utilisés
+GET /api/sources                          // Liste les sources
+GET /api/sources/{id}                     // Info sur une source
+GET /api/sources/{id}/root                // Container racine
+GET /api/sources/{id}/browse              // Parcourt un container
+GET /api/sources/{id}/resolve             // Résout l'URI d'un item
+GET /api/sources/{id}/image               // Image de la source
+GET /api/sources/{id}/capabilities        // Capacités de la source
+```
+
+**Fonctions implémentées :**
+- `listSources()` - Liste toutes les sources enregistrées
+- `getSource(id)` - Récupère une source spécifique
+- `getSourceRoot(id)` - Récupère le container racine
+- `browseSource(id, objectId?, pagination?)` - Navigation dans les containers
+- `resolveUri(sourceId, objectId)` - Résout l'URI de streaming
+- `getSourceImageUrl(id)` - URL de l'image de la source
+
+### 2. Composant Player (`pmoapp/webapp/src/components/GenericMusicPlayer.vue`)
+
+Composant Vue.js qui implémente :
+
+#### Fonctionnalités implémentées
+
+1. **Sélection de sources**
+   - Affichage de toutes les sources disponibles
+   - Affichage du logo de chaque source
+   - Affichage des capacités (FIFO, Search, Favorites)
+
+2. **Navigation dans les containers**
+   - Breadcrumb pour remonter dans la hiérarchie
+   - Affichage des sous-containers (dossiers)
+   - Navigation par clic dans les containers
+
+3. **Liste des morceaux**
+   - Affichage de tous les items audio d'un container
+   - Métadonnées : titre, artiste, album, cover art
+   - Numérotation des morceaux
+
+4. **Lecteur audio**
+   - Lecture d'un morceau via résolution d'URI
+   - Contrôles audio natifs HTML5
+   - Section "Now Playing" avec métadonnées
+   - Gestion des erreurs de lecture
+
+5. **Interface utilisateur**
+   - Design moderne avec dégradés et animations
+   - Responsive design
+   - Indicateurs visuels (morceau actif, en cours de lecture)
+   - Messages d'erreur clairs
+
+### 3. Intégration
+
+Le player a été configuré comme **page d'accueil par défaut** de l'application web PMO :
+
+```typescript
+// router/index.ts
+const routes = [
+  { path: "/", name: "home", component: GenericMusicPlayer },
+  // ... autres routes
+]
+```
+
+## Ce qui fonctionne
+
+✅ **Complètement fonctionnel avec l'API actuelle de pmosource :**
+
+1. Découverte des sources disponibles
+2. Navigation complète dans la hiérarchie des containers
+3. Affichage des métadonnées des morceaux
+4. Résolution des URIs et lecture audio
+5. Affichage des images de sources
+6. **Métadonnées temps réel via Server-Sent Events (SSE)** 🆕
+   - Mise à jour automatique toutes les 3 secondes
+   - Pas de polling, push serveur
+   - Reconnexion automatique
+
+## Limitations identifiées et améliorations possibles
+
+### 1. Métadonnées de couverture d'album
+
+**Problème :** Le trait `MusicSource` n'expose pas directement de méthode pour résoudre les URIs de couvertures d'album.
+
+**État actuel :**
+- Le champ `album_art` dans `Item` contient parfois une URI
+- Le champ `album_art_pk` contient une clé primaire mais pas d'URL exploitable directement
+- Certaines implémentations (pmoparadise) utilisent `/cache/cover/{pk}` mais ce n'est pas standardisé
+
+**Proposition :**
+```rust
+/// Résout l'URI de la couverture d'album pour un item
+async fn resolve_cover_uri(&self, object_id: &str) -> Result<Option<String>>;
+```
+
+### 2. Recherche globale
+
+**Problème :** La méthode `search()` existe mais retourne `SearchNotSupported` par défaut.
+
+**État actuel :**
+- Pas d'interface standardisée pour la recherche dans l'UI
+- Pas de retour clair sur les capacités de recherche
+
+**Proposition :**
+- Utiliser `capabilities().supports_search` pour afficher/masquer l'UI de recherche
+- Documenter clairement le format attendu des requêtes de recherche
+
+### 3. Pagination
+
+**Problème :** L'API supporte la pagination mais les métadonnées ne permettent pas de connaître le nombre total d'items.
+
+**État actuel :**
+- `BrowseResponse.total` retourne le nombre d'items retournés, pas le total disponible
+- Pas de méthode `get_total_count(object_id)` dans le trait
+
+**Proposition :**
+```rust
+/// Retourne le nombre total d'items dans un container
+async fn get_total_count(&self, object_id: &str) -> Result<usize>;
+```
+
+Ou ajouter `total_available` dans `BrowseResponse` :
+```rust
+pub struct SourceBrowseResponse {
+    // ... champs existants
+    pub total_available: Option<usize>, // Total disponible (pas juste retourné)
+}
+```
+
+### 4. Métadonnées de stream en temps réel ✅ **IMPLÉMENTÉ**
+
+**Solution implémentée :**
+- ✅ Méthode `get_item(object_id)` dans le trait `MusicSource`
+- ✅ Endpoint REST `GET /api/sources/{id}/item?object_id={id}` pour récupérer les métadonnées d'un item
+- ✅ Endpoint SSE `GET /api/sources/{id}/item/stream?object_id={id}` pour recevoir les mises à jour en temps réel
+- ✅ Le player web utilise Server-Sent Events (SSE) pour les métadonnées temps réel
+
+**Comment ça fonctionne :**
+1. Le serveur envoie automatiquement les métadonnées à jour toutes les 3 secondes via SSE
+2. Le client se connecte avec `EventSource` (API browser native)
+3. Les métadonnées sont automatiquement mises à jour dans l'interface sans polling
+
+**Pour RadioParadise :**
+- La méthode `get_item()` pour les live streams récupère les métadonnées depuis `/radioparadise/metadata/{slug}`
+- Le SSE permet d'avoir les métadonnées à jour en moins de 3 secondes (au lieu de 10 secondes avec le polling)
+
+### 5. Playlists utilisateur
+
+**Problème :** Les méthodes existent (`get_user_playlists()`, `add_to_playlist()`) mais retournent `NotSupported` par défaut.
+
+**État actuel :**
+- Pas encore testé dans le player
+- Nécessiterait une UI dédiée
+
+**Proposition :**
+- Créer une section "Playlists" dans le player
+- Tester l'API avec une implémentation qui supporte les playlists (ex: Qobuz)
+
+### 6. Favoris
+
+**Problème :** Similaire aux playlists, l'API existe mais n'est pas testée.
+
+**Proposition :**
+- Ajouter un bouton "⭐ Favoris" sur chaque morceau
+- Afficher visuellement les morceaux favoris
+- Créer une section "Mes Favoris"
+
+### 7. Auto-play / Queue
+
+**Problème :** Il n'y a pas de méthode pour gérer une file d'attente de lecture.
+
+**Proposition :**
+```rust
+/// Interface pour gérer une queue de lecture
+pub trait Playable: MusicSource {
+    async fn get_next_track(&self) -> Result<Option<Item>>;
+    async fn get_previous_track(&self) -> Result<Option<Item>>;
+    async fn add_to_queue(&self, item: Item) -> Result<()>;
+    async fn clear_queue(&self) -> Result<()>;
+    async fn get_queue(&self) -> Result<Vec<Item>>;
+}
+```
+
+### 8. Durée totale d'un container
+
+**Problème :** Pour afficher "Album: 45:32 min, 12 morceaux", il faut parcourir tous les items.
+
+**Proposition :**
+```rust
+/// Statistiques d'un container spécifique
+async fn get_container_stats(&self, object_id: &str) -> Result<ContainerStats>;
+
+pub struct ContainerStats {
+    pub item_count: usize,
+    pub total_duration_ms: Option<u64>,
+    pub total_size_bytes: Option<u64>,
+}
+```
+
+### 9. Formats audio disponibles
+
+**Problème :** La méthode `get_available_formats()` existe mais n'est pas exploitée dans l'UI.
+
+**Proposition :**
+- Ajouter un sélecteur de qualité dans le player
+- Afficher les formats disponibles (FLAC 24/96, MP3 320, etc.)
+
+### 10. État du cache
+
+**Problème :** Les méthodes existent (`get_cache_status()`, `cache_item()`) mais ne sont pas intégrées.
+
+**Proposition :**
+- Afficher un indicateur de cache sur chaque morceau
+- Bouton "📥 Télécharger" pour mettre en cache
+- Barre de progression pour le téléchargement
+
+## Prochaines étapes
+
+### Court terme
+1. ✅ Tester le player avec `pmoparadise` (déjà implémenté)
+2. 🔄 Identifier les bugs et limitations pratiques
+3. 🔄 Tester avec une deuxième source (ex: `pmoqobuz`) pour valider la généricité
+
+### Moyen terme
+1. Implémenter les fonctionnalités manquantes identifiées ci-dessus
+2. Ajouter la gestion de queue et auto-play
+3. Ajouter la recherche si supportée
+4. Intégrer la gestion du cache
+
+### Long terme
+1. Support des playlists utilisateur
+2. Support des favoris
+3. Égaliseur et effets audio
+4. Visualisations audio
+5. Mode hors-ligne avec cache
+
+## Conclusion
+
+Le player générique démontre que **l'API `pmosource` est déjà très utilisable** pour créer une application musicale fonctionnelle. Les principales limitations concernent :
+
+1. **Les métadonnées de couvertures** (pas d'URL standardisée)
+2. **La pagination avancée** (pas de compte total)
+3. **Les métadonnées temps réel** (pour les streams live)
+4. **La gestion de queue** (pas d'API dédiée)
+
+Ces limitations ne sont pas bloquantes mais leur résolution améliorerait significativement l'expérience utilisateur et la complétude de l'API.
+
+## Utilisation
+
+Pour tester le player :
+
+1. Lancer le serveur backend avec au moins une source enregistrée :
+   ```bash
+   cargo run --example single_channel_server --features full
+   ```
+
+2. Accéder à l'application web :
+   ```
+   http://localhost:8080/app/
+   ```
+
+3. Le player devrait afficher automatiquement les sources disponibles et permettre la navigation et la lecture.
+
+## Remarques importantes
+
+- ✅ Le player **n'utilise QUE l'API pmosource générique**
+- ✅ Aucune dépendance sur `pmoparadise` ou toute autre implémentation spécifique
+- ✅ Tout est basé sur les endpoints REST de `pmosource::api`
+- ✅ Le code est totalement réutilisable pour toute nouvelle source (Qobuz, Spotify, etc.)

PMOMusic/.pmomusic/config.yaml

@@ -0,0 +1,21 @@
+host:
+  http_port: '8080'
+  cover_cache:
+    directory: cache_covers
+    size: 2000
+  audio_cache:
+    directory: cache_audio
+    size: 500
+  logger:
+    buffer_capacity: 200
+    enable_console: true
+    min_level: INFO
+playlists:
+  directory: playlists
+devices:
+  mediarenderer:
+    pmo_mediarenderer:
+      udn: f77de90b-3a4a-408c-8462-3308ad500744
+  mediaserver:
+    pmo_mediaserver:
+      udn: 88b84e76-4de0-4ee6-b794-99cc4a278cc9

PMOMusic/Cargo.toml

@@ -6,12 +6,20 @@ edition = "2024"
 [dependencies]
 pmoconfig = { path = "../pmoconfig" }
 pmoupnp =  { path = "../pmoupnp"}
+pmomediarenderer = { path = "../pmomediarenderer" }
+pmomediaserver = { path = "../pmomediaserver", features = ["qobuz", "paradise", "paradise-api", "api"] }
+pmosource = { path = "../pmosource", features = ["server"] }
 pmoserver = { path = "../pmoserver" }
-pmoapp = { path = "../pmoapp" }
+pmocovers = { path = "../pmocovers", features = ["pmoserver"] }
+pmoaudiocache = { path = "../pmoaudiocache", features = ["pmoserver"]}
+pmoaudio-ext = { path = "../pmoaudio-ext", features = ["all"] }
+pmoapp = { path = "../pmoapp", features = ["pmoserver"] }
+pmocontrol = { path = "../pmocontrol", features = ["pmoserver"] }
 
-
-tokio = { version = "1.35", features = ["rt-multi-thread", "macros", "sync", "time","signal"] }
-tracing = "0.1.41"
+tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync", "time", "signal"] }
+tracing = { workspace = true }
 tracing-subscriber = "0.3.20"
 axum = "0.8.4"
 serde_json = "1.0.145"
+utoipa = "5.4"
+console-subscriber = "0.4.1"

PMOMusic/Cargo.toml.backup

@@ -0,0 +1,25 @@
+[package]
+name = "PMOMusic"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+pmoconfig = { path = "../pmoconfig" }
+pmoupnp =  { path = "../pmoupnp"}
+pmomediarenderer = { path = "../pmomediarenderer" }
+pmomediaserver = { path = "../pmomediaserver", features = ["qobuz", "paradise", "paradise-api", "api"] }
+pmosource = { path = "../pmosource", features = ["server"] }
+pmoserver = { path = "../pmoserver" }
+pmocovers = { path = "../pmocovers", features = ["pmoserver"] }
+pmoaudiocache = { path = "../pmoaudiocache", features = ["pmoserver"]}
+pmoaudio-ext = { path = "../pmoaudio-ext", features = ["all"] }
+pmoapp = { path = "../pmoapp", features = ["pmoserver"] }
+pmocontrol = { path = "../pmocontrol", features = ["pmoserver"] }
+
+tokio = { version = "1.35", features = ["rt-multi-thread", "macros", "sync", "time","signal"] }
+tracing = "0.1.41"
+tracing-subscriber = "0.3.20"
+axum = "0.8.4"
+serde_json = "1.0.145"
+utoipa = "5.4"
+console-subscriber = "0.4.1"

PMOMusic/src/main.rs

@@ -1,58 +1,137 @@
-use pmoupnp::{mediarenderer::avtransport::AVTTRANSPORT, UpnpObject};
-use pmoserver::{
-    logs::{log_dump, log_sse, LogState, SseLayer},
-    ServerBuilder
+use pmoapp::{WebAppExt, Webapp};
+use pmocontrol::ControlPointExt;
+use pmomediarenderer::MEDIA_RENDERER;
+use pmomediaserver::{
+    MEDIA_SERVER, MediaServerDeviceExt, ParadiseStreamingExt, sources::SourcesExt,
 };
-use pmoapp::Webapp;
-use tracing_subscriber::Registry;
-use tracing_subscriber::prelude::*;
+use pmoserver::Server;
+use pmosource::MusicSourceExt;
+use pmoupnp::UpnpServerExt;
 use tracing::info;
 
 #[tokio::main]
-async fn main() {
-    // Charger la config
-
-    let mut server = ServerBuilder::new_configured().build();
-
-    // Ajouter des routes
-    server
-        .add_route("/hello", || async {
-            serde_json::json!({"message": "Hello World"})
-        })
-        .await;
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // ========== PHASE 1 : Infrastructure UPnP ==========
+    // #[cfg(tokio_unstable)]
+    // console_subscriber::init();
 
+    let server = Server::create_upnp_server().await?; // Routes personnalisées de l'application
     server
+        .write()
+        .await
         .add_route("/info", || async {
             serde_json::json!({"version": "1.0.0"})
         })
         .await;
 
-    server.add_spa::<Webapp>("/app").await;
-
-    // Gère la sortie des logs et sur le serveur SSE pour l'interface web et sur la console
-    let log_state = LogState::new(1000);
-    let subscriber = Registry::default()
-        .with(
-            tracing_subscriber::fmt::layer()
-                .with_target(true)
-                .with_level(true)
-                .with_ansi(true), // Couleurs dans le terminal
-        )
-        .with(SseLayer::new(log_state.clone()));
-    tracing::subscriber::set_global_default(subscriber).unwrap();
-
+    // Initialiser le système de gestion des sources musicales avec API REST
+    info!("📡 Initializing music sources management system...");
     server
-        .add_handler_with_state("/log-sse", log_sse, log_state.clone())
-        .await;
+        .write()
+        .await
+        .init_music_sources()
+        .await
+        .expect("Failed to initialize music sources API");
+
+    // ========== PHASE 2 : Configuration métier ==========
+
+    // Enregistrer les sources musicales
+    info!("🎵 Registering music sources...");
+
+    // Enregistrer Qobuz pour activer les lazy providers (QOBUZ:PK)
+    if let Err(e) = server.write().await.register_qobuz().await {
+        tracing::warn!("⚠️ Failed to register Qobuz source: {}", e);
+    }
+
+    // Initialiser les canaux de streaming Radio Paradise (pipelines + routes HTTP)
+    info!("📻 Initializing Radio Paradise streaming channels...");
+    if let Err(e) = server.write().await.init_paradise_streaming().await {
+        tracing::warn!("⚠️ Failed to initialize Paradise streaming: {}", e);
+    } else {
+        // Enregistrer la source Radio Paradise UPnP (inclut l'initialisation de l'API)
+        if let Err(e) = server.write().await.register_paradise().await {
+            tracing::warn!("⚠️ Failed to register Radio Paradise source: {}", e);
+        }
+    }
+
+    // Lister toutes les sources enregistrées
+    let sources = server.read().await.list_music_sources().await;
+    info!("✅ {} music source(s) registered", sources.len());
+    for source in sources {
+        info!("  - {} ({})", source.name(), source.id());
+    }
+
+    // Enregistrer les devices UPnP (HTTP + SSDP automatique)
+    info!("📡 Registering UPnP devices...");
+
+    let renderer_instance = server
+        .write()
+        .await
+        .register_device(MEDIA_RENDERER.clone())
+        .await
+        .expect("Failed to register MediaRenderer");
+
+    info!(
+        "✅ MediaRenderer ready at {}{}",
+        renderer_instance.base_url(),
+        renderer_instance.description_route()
+    );
+
+    let server_instance = server
+        .write()
+        .await
+        .register_device(MEDIA_SERVER.clone())
+        .await
+        .expect("Failed to register MediaServer");
+
+    // Enregistrer l'instance ContentDirectory pour les notifications GENA
+    if let Some(cd_service) = server_instance.get_service("ContentDirectory") {
+        pmomediaserver::contentdirectory::state::register_instance(&cd_service);
+    }
+
+    // Initialiser les ProtocolInfo du MediaServer
+    server_instance.init_protocol_info();
+
+    info!(
+        "✅ MediaServer ready at {}{}",
+        server_instance.base_url(),
+        server_instance.description_route()
+    );
+
+    // Enregistrer le Control Point (découverte renderers/serveurs + API REST + SSE)
+    info!("🎛️  Registering Control Point...");
+    let _control_point = server
+        .write()
+        .await
+        .register_control_point(5)
+        .await
+        .expect("Failed to register Control Point");
+
+    // Ajouter la webapp via le trait WebAppExt
+    info!("📡 Registering Web application...");
     server
-        .add_handler_with_state("/log-dump", log_dump, log_state.clone())
+        .write()
+        .await
+        .add_webapp_with_redirect::<Webapp>("/app")
         .await;
 
-    server.add_redirect("/", "/app").await;
+    // ========== PHASE 3 : Démarrage du serveur ==========
 
-    info!("{}",AVTTRANSPORT.to_markdown());
-    info!("{}",AVTTRANSPORT.scpd_xml());
+    info!("🌐 Starting HTTP server...");
+    server.write().await.start().await;
 
-    server.start().await;
-    server.wait().await;
+    info!("✅ PMOMusic is ready!");
+    info!("Press Ctrl+C to stop...");
+
+    // Attendre le signal Ctrl+C et l'arrêt du serveur HTTP
+    server.write().await.wait().await;
+
+    // Le serveur HTTP est arrêté, mais des threads (ControlPoint, etc.) peuvent encore tourner
+    // Attendre 2 secondes pour laisser le temps aux threads de se terminer
+    info!("Waiting for background threads to finish...");
+    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+
+    // Forcer l'arrêt du processus (les threads du ControlPoint tournent en boucle infinie)
+    info!("✅ PMOMusic stopped");
+    std::process::exit(0);
 }

Plan_d_implementation_webui_control_point.md

@@ -0,0 +1,447 @@
+# PMOControl WebUI - Design Recommendations & Implementation Plan
+
+## Executive Summary
+
+Based on my analysis of the existing codebase, I'm providing comprehensive recommendations for implementing a Vue.js WebUI for PMOControl. The system already has:
+- A complete REST API with OpenAPI documentation (`/api/control/*`)
+- SSE endpoints for real-time updates (`/api/control/events/*`)
+- Vue 3 + TypeScript + Vite setup
+- Existing components (GenericMusicPlayer, UpnpExplorer, Cache Managers, LogView)
+
+---
+
+## Design Decisions & Recommendations
+
+### 1. State Management: **Use Pinia**
+
+**Recommendation: Pinia (Vue 3's official state management)**
+
+**Rationale:**
+- **Centralized real-time state**: Essential for managing SSE updates from multiple sources (renderers, media servers)
+- **Multi-client synchronization**: Single source of truth for renderer states, volumes, playback positions
+- **TypeScript native**: Better type inference than Vuex
+- **DevTools integration**: Built-in debugging for SSE event flows
+- **Composition API friendly**: Matches existing Vue 3 patterns in codebase
+- **Performance**: Lightweight (~1KB), modular stores
+- **Official Vue 3 recommendation**: Future-proof choice
+
+**Store Architecture:**
+```typescript
+// stores/renderers.ts - Renderer state (SSE updates)
+// stores/mediaServers.ts - Media server state (SSE updates)
+// stores/playback.ts - Current playback session
+// stores/ui.ts - UI state (selected renderer, view preferences)
+```
+
+**Benefits for your use case:**
+- Handle 20+ concurrent clients with shared state
+- Real-time SSE event synchronization across all views
+- Easy to scale with multi-renderer, multi-server, multi-session architecture
+
+---
+
+### 2. UI Component Library: **Headless UI + Custom Components**
+
+**Recommendation: Hybrid approach - Headless UI components + custom styling**
+
+**Component Library: Shadcn-vue (Headless UI primitives)**
+
+**Rationale:**
+- **Lightweight & performant**: Only import what you need
+- **Full style control**: Match "carte uniforme, responsive, colorée selon statut" spec exactly
+- **TypeScript-first**: Perfect type safety
+- **Accessibility built-in**: ARIA compliance out of the box
+- **No theme lock-in**: Complete CSS freedom
+- **Composable primitives**: Card, Dialog, Dropdown, Slider components
+
+**Why NOT a full framework (Vuetify, Element Plus)?**
+- Heavy bundle size (100-500KB vs ~10KB for headless)
+- Theme customization overhead
+- Your spec requires custom status-based coloring
+- Performance critical with 20 concurrent clients
+
+**Alternative if you prefer pre-styled:** PrimeVue
+- Good performance
+- Customizable themes
+- Strong TypeScript support
+- But: 150KB+ bundle size
+
+**Custom Components to Build:**
+- `RendererCard` - Status-colored cards for each renderer
+- `TransportControls` - Play/Pause/Stop/Next buttons
+- `VolumeControl` - Slider with mute toggle
+- `QueueViewer` - Playlist display with drag-drop
+- `MediaServerBrowser` - Container navigation
+
+---
+
+### 3. Existing Components: **Reorganize into Debug Section**
+
+**Recommendation: Keep existing components, create new PMOControl home**
+
+**Structure:**
+```
+/app (root) → PMOControl Dashboard (NEW)
+/app/debug → Dropdown menu
+  ├─ /logs → LogView
+  ├─ /upnp → UpnpExplorer
+  ├─ /covers-cache → CoverCacheManager
+  ├─ /audio-cache → AudioCacheManager
+  ├─ /api-dashboard → APIDashboard
+  └─ /radio-paradise → RadioParadiseExplorer
+```
+
+**Rationale:**
+- Existing components are valuable for development/debugging
+- Don't break existing functionality
+- PMOControl becomes primary interface as specified
+- Debug tools remain accessible but not prominent
+- Matches current App.vue dropdown pattern
+
+**Home Screen (/) - PMOControl Dashboard:**
+- Grid of renderer cards (status-colored)
+- Active playback session viewer
+- Quick controls (play/pause/volume)
+- Media server browser panel
+
+---
+
+### 4. Responsive Design: **Mobile-first with 3 breakpoints**
+
+**Recommendation: Follow existing 768px pattern + add tablet/desktop**
+
+**Breakpoints:**
+```css
+/* Mobile: < 768px (existing pattern) */
+- Single column layout
+- Stacked renderer cards
+- Bottom-fixed playback controls
+- Collapsible media browser
+
+/* Tablet: 768px - 1024px */
+- Two column layout
+- Grid of renderer cards (2 columns)
+- Side panel for media browser
+- Floating playback controls
+
+/* Desktop: > 1024px */
+- Three column layout
+- Renderer cards grid (3-4 columns)
+- Persistent media browser sidebar
+- Always-visible playback controls
+```
+
+**Target Devices:**
+- **Primary**: Desktop browsers (control station)
+- **Secondary**: Tablets (remote control)
+- **Tertiary**: Mobile phones (quick controls)
+
+**Performance considerations:**
+- Virtualized lists for 20+ renderers (use vue-virtual-scroller)
+- Lazy load album art
+- Throttle SSE position updates (max 1/sec per renderer)
+
+---
+
+### 5. Icons: **Lucide Icons (SVG library)**
+
+**Recommendation: Lucide Icons (NOT emoji)**
+
+**Rationale:**
+- **Professional appearance**: Emojis inconsistent across platforms
+- **Customizable**: Size, color, stroke width
+- **Lightweight**: Tree-shakeable SVG imports (~1KB per icon)
+- **Status coloring**: Icons can match card status colors
+- **Accessibility**: Proper ARIA labels
+- **Vue components**: `lucide-vue-next` package
+
+**Icon mapping:**
+```typescript
+Play → PlayCircle
+Pause → PauseCircle
+Stop → StopCircle
+Next → SkipForward
+Volume → Volume2 / VolumeX (muted)
+Renderer → Speaker / MonitorSpeaker
+Server → Server / Database
+Queue → ListMusic
+```
+
+**Alternative if you prefer minimal bundle:** Heroicons
+- Smaller set (fewer icons)
+- Tailwind CSS integration
+- But: less comprehensive for music player needs
+
+**Why NOT emoji:**
+- Platform inconsistencies (iOS ≠ Android ≠ Windows)
+- No color control
+- Accessibility issues
+- Unprofessional for production UI
+
+---
+
+## Technical Architecture
+
+### Real-time SSE Integration
+
+**SSE Event Handling:**
+```typescript
+// services/controlPointSSE.ts
+class ControlPointSSE {
+  private eventSource: EventSource
+  private renderersStore: ReturnType<typeof useRenderersStore>
+
+  connect() {
+    this.eventSource = new EventSource('/api/control/events')
+
+    this.eventSource.addEventListener('control', (e) => {
+      const event = JSON.parse(e.data)
+
+      if (event.category === 'renderer') {
+        this.handleRendererEvent(event)
+      } else if (event.category === 'media_server') {
+        this.handleServerEvent(event)
+      }
+    })
+  }
+
+  handleRendererEvent(event: RendererEventPayload) {
+    switch (event.type) {
+      case 'state_changed':
+        this.renderersStore.updateState(event.renderer_id, event.state)
+        break
+      case 'volume_changed':
+        this.renderersStore.updateVolume(event.renderer_id, event.volume)
+        break
+      // ... handle all event types
+    }
+  }
+}
+```
+
+**Store Integration:**
+```typescript
+// stores/renderers.ts
+export const useRenderersStore = defineStore('renderers', () => {
+  const renderers = ref<Map<string, RendererState>>(new Map())
+
+  // SSE updates
+  function updateState(id: string, state: string) {
+    const renderer = renderers.value.get(id)
+    if (renderer) {
+      renderer.transport_state = state
+    }
+  }
+
+  // REST API calls
+  async function play(id: string) {
+    await fetch(`/api/control/renderers/${id}/play`, { method: 'POST' })
+    // SSE will update state automatically
+  }
+
+  return { renderers, updateState, play }
+})
+```
+
+### Performance Optimizations
+
+**For 20+ concurrent clients:**
+
+1. **Throttle position updates**:
+   ```typescript
+   const throttledPositionUpdate = throttle((id, pos) => {
+     store.updatePosition(id, pos)
+   }, 1000) // Max 1 update/second
+   ```
+
+2. **Virtual scrolling** for renderer lists:
+   ```bash
+   npm install vue-virtual-scroller
+   ```
+
+3. **Lazy load album art**:
+   ```vue
+   <img :src="albumArt" loading="lazy" />
+   ```
+
+4. **Debounce volume sliders**:
+   ```typescript
+   const debouncedVolumeChange = debounce((id, vol) => {
+     api.setVolume(id, vol)
+   }, 300)
+   ```
+
+5. **Memoize computed properties**:
+   ```typescript
+   const activeRenderers = computed(() =>
+     renderers.value.filter(r => r.online)
+   )
+   ```
+
+---
+
+## Implementation Roadmap
+
+### Phase 1: Core Infrastructure (Week 1)
+1. Install Pinia + configure stores
+2. Install Lucide Icons
+3. Create SSE service layer
+4. Setup store structure (renderers, servers, playback, ui)
+5. Connect SSE events to stores
+
+### Phase 2: UI Components (Week 2)
+5. Build RendererCard component (status-colored)
+6. Build TransportControls component
+7. Build VolumeControl component
+8. Build QueueViewer component
+9. Create responsive grid layouts
+
+### Phase 3: Dashboard Assembly (Week 3)
+10. Create PMOControl home view
+11. Integrate all components
+12. Add media server browser panel
+13. Implement responsive breakpoints
+14. Add loading states & error handling
+
+### Phase 4: Polish & Testing (Week 4)
+15. Test with 20+ concurrent clients
+16. Performance profiling & optimization
+17. Accessibility audit (ARIA, keyboard nav)
+18. Cross-browser testing
+19. Mobile/tablet testing
+20. Documentation
+
+---
+
+## Dependencies to Install
+
+```json
+{
+  "dependencies": {
+    "pinia": "^2.2.8",
+    "lucide-vue-next": "^0.470.0",
+    "vue-virtual-scroller": "^2.0.0-beta.8"
+  },
+  "devDependencies": {
+    // Already installed: vue, vue-router, typescript, vite
+  }
+}
+```
+
+**Total bundle size estimate:** +15KB gzipped (Pinia + Lucide + Virtual Scroller)
+
+---
+
+## Status-based Coloring Scheme
+
+Based on "carte uniforme, responsive, colorée selon statut" spec:
+
+```css
+/* Renderer Card Status Colors */
+.renderer-card.playing {
+  border-color: #22c55e; /* green */
+  background: linear-gradient(135deg, #22c55e10, transparent);
+}
+
+.renderer-card.paused {
+  border-color: #f59e0b; /* amber */
+  background: linear-gradient(135deg, #f59e0b10, transparent);
+}
+
+.renderer-card.stopped {
+  border-color: #6b7280; /* gray */
+  background: linear-gradient(135deg, #6b728010, transparent);
+}
+
+.renderer-card.offline {
+  border-color: #ef4444; /* red */
+  background: linear-gradient(135deg, #ef444410, transparent);
+  opacity: 0.6;
+}
+
+.renderer-card.transitioning {
+  border-color: #3b82f6; /* blue */
+  background: linear-gradient(135deg, #3b82f610, transparent);
+  animation: pulse 2s infinite;
+}
+```
+
+---
+
+## Answers to Your Specific Questions
+
+### 1. State Management?
+**Answer: Pinia** - Vue 3 official, perfect for SSE real-time updates, TypeScript native, lightweight
+
+### 2. UI Component Library?
+**Answer: Headless UI (Shadcn-vue) + Custom Components** - Full control over status-based styling, lightweight, no theme lock-in
+
+### 3. Keep existing components?
+**Answer: Yes, reorganize into Debug section** - Keep valuable dev tools, make PMOControl the new home screen
+
+### 4. Responsive breakpoints?
+**Answer: Mobile-first with 3 breakpoints** - <768px (mobile), 768-1024px (tablet), >1024px (desktop)
+
+### 5. Icons?
+**Answer: Lucide Icons (SVG library)** - Professional, customizable, status-colored, NOT emoji
+
+---
+
+## Risk Mitigation
+
+**Potential challenges:**
+
+1. **SSE connection management across tabs**
+   - Solution: Use BroadcastChannel API for cross-tab sync
+   - Fallback: LocalStorage events
+
+2. **20+ renderers performance**
+   - Solution: Virtual scrolling + throttled updates
+   - Monitor: Chrome DevTools Performance profiler
+
+3. **Network reliability (SSE reconnection)**
+   - Solution: Exponential backoff reconnection
+   - UI indicator for connection status
+
+4. **Album art loading (CORS, 404s)**
+   - Solution: Proxy through backend
+   - Fallback: Default placeholder image
+
+5. **Browser compatibility (SSE support)**
+   - Chrome/Edge: Native support ✅
+   - Firefox: Native support ✅
+   - Safari: Native support ✅
+   - IE11: Use EventSource polyfill
+
+---
+
+## Success Metrics
+
+**Performance targets:**
+- Initial load: <2s (FCP)
+- SSE event latency: <100ms
+- UI interaction: <16ms (60fps)
+- Memory usage: <50MB with 20 renderers
+- Bundle size: <250KB gzipped
+
+**Functionality checklist:**
+- [ ] Display all discovered renderers in real-time
+- [ ] Show accurate playback state (play/pause/stop)
+- [ ] Volume control works across all renderer types
+- [ ] Queue display syncs with server
+- [ ] Media server browsing functional
+- [ ] Playlist attachment working
+- [ ] Responsive on mobile/tablet/desktop
+- [ ] Accessible (WCAG AA compliance)
+- [ ] 20+ concurrent clients supported
+
+---
+
+## Next Steps
+
+1. **Review & approve** this plan with stakeholders
+2. **Clarify any ambiguities** in requirements
+3. **Set up development environment** (install dependencies)
+4. **Begin Phase 1** (Core Infrastructure)
+
+Would you like me to proceed with implementation, or do you have questions about any of these recommendations?

Readme.md

@@ -1,5 +1,43 @@
 # Développement de l'application PMOMusic en RUST
 
+## 🚀 Démarrage rapide
+
+### Installation des dépendances (environnement sans sudo)
+
+Pour compiler PMOMusic dans un environnement sans privilèges sudo (comme Claude Code) :
+
+```bash
+# 1. Installation automatique de libsoxr et libasound2 (une seule fois)
+./setup-deps.sh
+
+# 2. Créer le fichier setup-env.sh (une seule fois, voir INSTALL_LIBSOXR.md pour le contenu)
+cat > setup-env.sh << 'EOF'
+#!/bin/bash
+export PKG_CONFIG_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH"
+export LD_LIBRARY_PATH="$HOME/.local/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+export RUSTFLAGS="-L $HOME/.local/usr/lib/x86_64-linux-gnu"
+echo "Variables d'environnement configurées pour PMOMusic"
+EOF
+
+# 3. Configuration de l'environnement (à chaque nouvelle session)
+source setup-env.sh
+
+# 4. Compilation
+cargo build
+
+# 5. Test de l'exemple Radio Paradise
+cargo run --package pmoparadise --example play_and_cache --features full -- 0
+```
+
+⚠️ **Note :** Le fichier `setup-env.sh` est dans `.gitignore` car il contient une configuration locale.
+
+### Documentation
+
+- **[INSTALL_NOTES.md](INSTALL_NOTES.md)** - Guide d'installation général
+- **[INSTALL_LIBSOXR.md](INSTALL_LIBSOXR.md)** - Installation détaillée de libsoxr et ALSA
+
+---
+
 ## Création de la structure
 
 ```bash
@@ -98,3 +136,10 @@ jj rebase --continue
 
 pour résoudre les conflits
 
+## Installer rust sur mac
+
+```bash
+brew install rustup-init
+rustup-init
+rustup default stable
+```

SECURITY_CONFIG.md

@@ -0,0 +1,27 @@
+# Configuration Sécurisée
+
+## Configuration de PMOMusic
+
+Le fichier `.pmomusic.yml` contient des informations sensibles (mots de passe, identifiants).
+
+### Installation
+
+1. Copiez le fichier exemple :
+   ```bash
+   cp .pmomusic.yml.example .pmomusic.yml
+   ```
+
+2. Éditez `.pmomusic.yml` et remplacez les valeurs par vos véritables identifiants :
+   - `accounts.qobuz.username` : votre email Qobuz
+   - `accounts.qobuz.password` : votre mot de passe Qobuz
+
+3. **Important** : Ne commitez JAMAIS le fichier `.pmomusic.yml` dans git !
+   - Il est déjà dans `.gitignore`
+   - Utilisez des variables d'environnement pour la production
+
+## Variables d'environnement (recommandé pour production)
+
+```bash
+export QOBUZ_USERNAME="votre-email@example.com"
+export QOBUZ_PASSWORD="votre-mot-de-passe"
+```

UPNP_ANALYSIS_REPORT.md

@@ -0,0 +1,243 @@
+# Rapport d'Analyse UPnP - PMO Music vs Serveurs Fonctionnels
+
+**Date:** 2025-11-26
+**Problème:** Le serveur UPnP de PMO Music n'est pas reconnu par BubbleUPnP
+
+## Résumé Exécutif
+
+Le serveur PMO Music MediaServer est correctement découvert via SSDP et répond aux requêtes SOAP, mais présente plusieurs différences avec les serveurs qui fonctionnent (comme Upmpdcli). Les problèmes identifiés sont principalement liés aux en-têtes HTTP et aux métadonnées du device.
+
+## Découverte Réseau
+
+### Devices UPnP Détectés
+
+| Device | IP | USN | Status |
+|--------|------|-----|---------|
+| PMO Music MediaServer | 192.168.0.138:8080 | uuid:8b8e9b19-9c65-4d59-b127-b34717658085 | ✅ Découvert |
+| Upmpdcli (pizzicato) | 192.168.0.200:49152 | uuid:c110358f-d885-b44a-d6d3-dca6329ead0d | ✅ Découvert |
+| Freebox | 192.168.0.254:52424 | uuid:e929a46e-d218-377d-2dde-32bd8080dfbf | ✅ Découvert |
+| Jellyfin | 192.168.0.34:8096 | uuid:526dedec-fde2-4224-bac6-06f7b11711cf | ✅ Découvert |
+
+**Conclusion SSDP:** ✅ PMO Music est correctement annoncé et découvert via SSDP
+
+## Comparaison des Descripteurs XML
+
+### PMO Music MediaServer
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<root xmlns="urn:schemas-upnp-org:device-1-0">
+  <specVersion>
+    <major>1</major>
+    <minor>0</minor>  <!-- ⚠️ Version 1.0 -->
+  </specVersion>
+  <device>
+    <deviceType>urn:schemas-upnp-org:device:MediaServer:1</deviceType>
+    <friendlyName>PMOMusic Media Server</friendlyName>
+    <manufacturer>PMOMusic</manufacturer>
+    <modelName>PMOMusic Media Server</modelName>
+    <UDN>uuid:8b8e9b19-9c65-4d59-b127-b34717658085</UDN>  <!-- ✅ Format correct -->
+    <!-- ❌ Pas d'iconList -->
+    <serviceList>
+      <service>
+        <serviceType>urn:schemas-upnp-org:service:ContentDirectory:1</serviceType>
+        <serviceId>urn:upnp-org:serviceId:ContentDirectory</serviceId>
+        <SCPDURL>/device/.../service/ContentDirectory/desc.xml</SCPDURL>
+        <controlURL>/device/.../service/ContentDirectory/control</controlURL>
+        <eventSubURL>/device/.../service/ContentDirectory/event</eventSubURL>
+      </service>
+      <service>
+        <serviceType>urn:schemas-upnp-org:service:ConnectionManager:1</serviceType>
+        ...
+      </service>
+    </serviceList>
+  </device>
+</root>
+```
+
+### Upmpdcli (Fonctionnel)
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<root xmlns="urn:schemas-upnp-org:device-1-0">
+  <specVersion>
+    <major>1</major>
+    <minor>1</minor>  <!-- ✅ Version 1.1 -->
+  </specVersion>
+  <device>
+    <deviceType>urn:schemas-upnp-org:device:MediaServer:1</deviceType>
+    <manufacturer>lesbonscomptes.com/upmpdcli</manufacturer>
+    <modelName>Upmpdcli Media Server</modelName>
+    <friendlyName>pizzicato-Music-mediaserver</friendlyName>
+    <iconList>  <!-- ✅ Présence d'icônes -->
+      <icon>
+        <mimetype>image/png</mimetype>
+        <width>64</width>
+        <height>64</height>
+        <depth>32</depth>
+        <url>/uuid-.../icon.png</url>
+      </icon>
+    </iconList>
+    <UDN>uuid:c110358f-d885-b44a-d6d3-dca6329ead0d</UDN>
+    <serviceList>
+      <!-- Mêmes services -->
+    </serviceList>
+  </device>
+</root>
+```
+
+### Différences Clés dans le Descripteur
+
+| Élément | PMO Music | Upmpdcli | Impact |
+|---------|-----------|----------|---------|
+| **specVersion minor** | 0 | 1 | ⚠️ Moyen - Certains clients peuvent filtrer par version |
+| **Ordre des éléments** | deviceType, friendlyName, manufacturer, modelName, UDN | deviceType, manufacturer, modelName, friendlyName, iconList, UDN | ⚠️ Faible - Ordre différent mais valide XML |
+| **iconList** | ❌ Absent | ✅ Présent | ⚠️ Moyen - Requis pour certains clients |
+| **UDN prefix** | ✅ uuid: | ✅ uuid: | ✅ Correct |
+
+## Comparaison des Réponses SOAP
+
+### Test 1: ConnectionManager::GetProtocolInfo
+
+#### PMO Music
+```http
+Status: 200 OK
+Content-Type: (absent)  ⚠️ PROBLÈME CRITIQUE
+
+<?xml version="1.0" encoding="UTF-8"?>
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"
+            s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+  <s:Body>
+    <u:GetProtocolInfoResponse xmlns:u="urn:schemas-upnp-org:service:ConnectionManager:1">
+      <Source></Source>  ⚠️ Vide
+      <Sink></Sink>      ⚠️ Vide
+    </u:GetProtocolInfoResponse>
+  </s:Body>
+</s:Envelope>
+```
+
+#### Upmpdcli
+```http
+Status: 200 OK
+Content-Type: text/xml; charset="utf-8"  ✅ Présent
+
+<?xml version="1.0"?>
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"
+            s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+  <s:Body>
+    <u:GetProtocolInfoResponse xmlns:u="urn:schemas-upnp-org:service:ConnectionManager:1">
+      <Source></Source>
+      <Sink>http-get:*:audio/flac:*,http-get:*:audio/mp3:*,...</Sink>  ✅ Formats listés
+    </u:GetProtocolInfoResponse>
+  </s:Body>
+</s:Envelope>
+```
+
+### Test 2: ContentDirectory::Browse
+
+Les deux serveurs répondent correctement, mais PMO Music manque toujours le header `Content-Type`.
+
+## Problèmes Identifiés par Ordre de Criticité
+
+### 🔴 CRITIQUE
+
+1. **Absence du header Content-Type dans les réponses SOAP**
+   - **Impact:** Les clients UPnP stricts (comme BubbleUPnP) peuvent rejeter les réponses sans Content-Type
+   - **Spec UPnP:** La spécification UPnP Device Architecture 1.0 exige `Content-Type: text/xml; charset="utf-8"`
+   - **Localisation probable:** Dans le code de réponse SOAP du serveur UPnP
+   - **Fichiers à vérifier:**
+     - `pmoupnp/src/services/service_instance.rs` (handler SOAP)
+     - `pmoupnp/src/soap/builder.rs`
+
+2. **ProtocolInfo vide pour Source et Sink**
+   - **Impact:** Les clients ne savent pas quels formats audio sont supportés
+   - **Spec UPnP:** ConnectionManager doit annoncer les formats supportés
+   - **Action:** Implémenter la liste des formats dans ConnectionManager
+
+### 🟡 MOYEN
+
+3. **specVersion 1.0 au lieu de 1.1**
+   - **Impact:** Certains clients modernes peuvent filtrer les devices UPnP 1.0
+   - **Solution:** Passer à specVersion 1.1
+
+4. **Absence d'iconList**
+   - **Impact:** Pas d'icône visible dans les clients UPnP
+   - **Solution:** Ajouter au moins une icône PNG 64x64
+
+### 🟢 FAIBLE
+
+5. **Ordre des éléments XML différent**
+   - **Impact:** Minimal - XML valide dans tous les cas
+   - **Action:** Optionnel - standardiser l'ordre
+
+## Recommandations d'Implémentation
+
+### Priorité 1: Corriger le Content-Type
+
+Localiser le code qui génère les réponses SOAP et ajouter le header:
+
+```rust
+// Dans pmoupnp/src/services/service_instance.rs ou similaire
+(
+    StatusCode::OK,
+    [(header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],  // ← AJOUTER
+    xml
+)
+```
+
+### Priorité 2: Implémenter GetProtocolInfo correctement
+
+Dans ConnectionManager, retourner la liste des formats supportés:
+
+```rust
+// Exemple de formats à supporter
+let sink_protocols = vec![
+    "http-get:*:audio/flac:*",
+    "http-get:*:audio/mpeg:*",
+    "http-get:*:audio/mp4:*",
+    "http-get:*:audio/ogg:*",
+    // ...
+];
+```
+
+### Priorité 3: Passer à UPnP 1.1
+
+Changer la specVersion de 1.0 à 1.1 dans le device descriptor.
+
+### Priorité 4: Ajouter une icône
+
+Créer une icône PNG 64x64 et l'ajouter au descripteur:
+
+```xml
+<iconList>
+  <icon>
+    <mimetype>image/png</mimetype>
+    <width>64</width>
+    <height>64</height>
+    <depth>32</depth>
+    <url>/icon.png</url>
+  </icon>
+</iconList>
+```
+
+## Fichiers à Modifier
+
+1. **pmoupnp/src/services/service_instance.rs** - Ajouter Content-Type aux réponses SOAP
+2. **pmoupnp/src/devices/device_methods.rs** - Ajouter iconList au descripteur
+3. **pmoupnp/src/devices/device.rs** - Passer specVersion à 1.1
+4. **pmomediaserver/src/connectionmanager/actions/getprotocolinfo.rs** - Implémenter la liste des formats
+
+## Tests de Validation
+
+Après les corrections, vérifier:
+
+1. ✅ `curl` sur le descripteur montre specVersion 1.1 et iconList
+2. ✅ Requête SOAP GetProtocolInfo retourne `Content-Type: text/xml`
+3. ✅ GetProtocolInfo retourne les formats supportés dans Sink
+4. ✅ BubbleUPnP détecte et affiche le serveur PMO Music
+
+## Conclusion
+
+Le serveur PMO Music est **fonctionnellement correct** au niveau de SSDP et des services SOAP, mais présente des problèmes de conformité aux standards UPnP qui peuvent causer des rejets par certains clients stricts comme BubbleUPnP.
+
+Les corrections sont simples et localisées. La priorité absolue est d'ajouter le header `Content-Type` aux réponses SOAP.

UPNP_FIX_SUMMARY.md

@@ -0,0 +1,128 @@
+# Résolution du Problème UPnP - PMO Music MediaServer
+
+**Date:** 2025-11-26
+**Problème:** Le serveur UPnP de PMO Music n'est pas reconnu par BubbleUPnP
+
+## Diagnostic
+
+Après une analyse approfondie avec des outils de découverte UPnP et de tests SOAP, le problème identifié était :
+
+**🔴 PROBLÈME CRITIQUE : `SourceProtocolInfo` vide**
+
+Le service `ConnectionManager` du MediaServer retournait des valeurs vides pour `SourceProtocolInfo`, ce qui empêchait les clients UPnP (comme BubbleUPnP) de savoir quels formats audio le serveur pouvait fournir.
+
+### Réponse AVANT la correction :
+
+```xml
+<u:GetProtocolInfoResponse>
+  <Source></Source>  <!-- ❌ VIDE -->
+  <Sink></Sink>
+</u:GetProtocolInfoResponse>
+```
+
+## Solution Implémentée
+
+### 1. Nouveau Module : `device_ext.rs`
+
+Création d'un trait d'extension `MediaServerDeviceExt` pour `Arc<DeviceInstance>` qui initialise automatiquement les `ProtocolInfo`.
+
+**Fichier:** [`pmomediaserver/src/device_ext.rs`](pmomediaserver/src/device_ext.rs)
+
+```rust
+pub trait MediaServerDeviceExt {
+    /// Initialise les ProtocolInfo du ConnectionManager pour PMO Music.
+    ///
+    /// PMO Music convertit tous les flux audio en FLAC (et OGG-FLAC).
+    fn init_protocol_info(&self);
+}
+```
+
+### 2. Formats Supportés
+
+PMO Music convertit tout au vol en FLAC, donc `SourceProtocolInfo` annonce :
+
+- `http-get:*:audio/flac:*` - FLAC standard
+- `http-get:*:audio/x-flac:*` - FLAC (format alternatif)
+- `http-get:*:application/flac:*` - FLAC (MIME type alternatif)
+- `http-get:*:application/x-flac:*` - FLAC (MIME type alternatif)
+- `http-get:*:application/ogg:*` - OGG-FLAC
+- `http-get:*:audio/ogg:*` - OGG-FLAC
+- `http-get:*:audio/x-ogg:*` - OGG-FLAC (format alternatif)
+
+### 3. Intégration dans `main.rs`
+
+**Fichier:** [`PMOMusic/src/main.rs`](PMOMusic/src/main.rs)
+
+```rust
+use pmomediaserver::MediaServerDeviceExt;
+
+let server_instance = server
+    .write()
+    .await
+    .register_device(MEDIA_SERVER.clone())
+    .await
+    .expect("Failed to register MediaServer");
+
+// ✅ Initialiser les ProtocolInfo du MediaServer
+server_instance.init_protocol_info();
+```
+
+### 4. Export dans `lib.rs`
+
+**Fichier:** [`pmomediaserver/src/lib.rs`](pmomediaserver/src/lib.rs)
+
+```rust
+pub mod device_ext;
+pub use device_ext::MediaServerDeviceExt;
+```
+
+## Réponse APRÈS la correction
+
+```xml
+<u:GetProtocolInfoResponse>
+  <Source>http-get:*:audio/flac:*,http-get:*:audio/x-flac:*,http-get:*:application/flac:*,http-get:*:application/x-flac:*,http-get:*:application/ogg:*,http-get:*:audio/ogg:*,http-get:*:audio/x-ogg:*</Source>  <!-- ✅ INITIALISÉ -->
+  <Sink></Sink>  <!-- ✅ Vide pour un MediaServer (normal) -->
+</u:GetProtocolInfoResponse>
+```
+
+## Fichiers Modifiés
+
+1. ✅ **Nouveau:** `pmomediaserver/src/device_ext.rs` - Trait d'extension pour initialiser ProtocolInfo
+2. ✅ **Modifié:** `pmomediaserver/src/lib.rs` - Export du trait
+3. ✅ **Modifié:** `PMOMusic/src/main.rs` - Appel à `init_protocol_info()`
+
+## Test de Validation
+
+Après redémarrage du serveur PMO Music, vérifier avec :
+
+```bash
+python3 tools/test_soap.py
+```
+
+Ou directement :
+
+```bash
+curl -X POST \
+  -H "Content-Type: text/xml" \
+  -H "SOAPAction: \"urn:schemas-upnp-org:service:ConnectionManager:1#GetProtocolInfo\"" \
+  -d '<?xml version="1.0"?>
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
+  <s:Body>
+    <u:GetProtocolInfo xmlns:u="urn:schemas-upnp-org:service:ConnectionManager:1"/>
+  </s:Body>
+</s:Envelope>' \
+  http://localhost:8080/device/.../service/ConnectionManager/control
+```
+
+## Prochaines Étapes
+
+1. ✅ Redémarrer le serveur PMO Music
+2. ⏳ Tester avec BubbleUPnP pour confirmer que le serveur est maintenant reconnu
+3. ⏳ (Optionnel) Ajouter une icône pour le MediaServer (amélioration UX)
+4. ⏳ (Optionnel) Passer à specVersion 1.1 (amélioration de compatibilité)
+
+## Références
+
+- Rapport d'analyse complet : [`UPNP_ANALYSIS_REPORT.md`](UPNP_ANALYSIS_REPORT.md)
+- UPnP AV Architecture Specification :
+  https://openconnectivity.org/developer/specifications/upnp-resources/upnp/

analyze_flac.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Affiche toutes les stats d'un fichier FLAC
+
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 <fichier.flac>"
+    exit 1
+fi
+
+FILE="$1"
+
+if [ ! -f "$FILE" ]; then
+    echo "Error: File not found: $FILE"
+    exit 1
+fi
+
+echo "=== Analyzing: $(basename "$FILE") ==="
+echo ""
+echo "--- SoX Statistics ---"
+sox "$FILE" -n stat 2>&1
+
+echo ""
+echo "--- File Info ---"
+file "$FILE"
+
+echo ""
+echo "--- FLAC Metadata ---"
+metaflac --list "$FILE" 2>/dev/null || echo "metaflac not installed"
+
+echo ""
+echo "--- Audio Integrity Check ---"
+flac -t "$FILE" 2>&1 || echo "flac not installed"

check_audio_quality.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+# Script pour vérifier la qualité audio (détection de clics via le ratio delta)
+
+CACHE_DIR="${1:-/tmp/pmomusic_test/audio_cache}"
+THRESHOLD=10.0  # Ratio Maximum delta / Mean delta acceptable
+
+if [ ! -d "$CACHE_DIR" ]; then
+    echo "Error: Cache directory not found: $CACHE_DIR"
+    exit 1
+fi
+
+echo "=== Audio Quality Check ==="
+echo "Scanning: $CACHE_DIR"
+echo "Threshold: Maximum/Mean delta ratio < $THRESHOLD"
+echo ""
+
+# Vérifier que sox est installé
+if ! command -v sox &> /dev/null; then
+    echo "Error: sox is not installed. Install it with: sudo apt install sox"
+    exit 1
+fi
+
+count=0
+suspicious=0
+good=0
+
+for file in "$CACHE_DIR"/*.orig.flac; do
+    if [ ! -f "$file" ]; then
+        echo "No FLAC files found in $CACHE_DIR"
+        exit 0
+    fi
+
+    filename=$(basename "$file")
+
+    # Obtenir les stats delta
+    stats=$(sox "$file" -n stat 2>&1)
+
+    max_delta=$(echo "$stats" | grep "Maximum delta" | awk '{print $3}')
+    mean_delta=$(echo "$stats" | grep "Mean    delta" | awk '{print $3}')
+
+    if [ -z "$max_delta" ] || [ -z "$mean_delta" ]; then
+        echo "❌ $filename - Cannot parse stats"
+        suspicious=$((suspicious + 1))
+        count=$((count + 1))
+        continue
+    fi
+
+    # Éviter division par zéro
+    if (( $(echo "$mean_delta == 0" | bc -l) )); then
+        echo "❌ $filename - Invalid mean delta (0)"
+        suspicious=$((suspicious + 1))
+        count=$((count + 1))
+        continue
+    fi
+
+    # Calculer le ratio
+    ratio=$(echo "scale=2; $max_delta / $mean_delta" | bc -l)
+
+    # Comparer au seuil
+    is_bad=$(echo "$ratio > $THRESHOLD" | bc -l)
+
+    if [ "$is_bad" = "1" ]; then
+        echo "⚠️  CLICKS DETECTED: $filename"
+        echo "    Max delta: $max_delta, Mean delta: $mean_delta, Ratio: ${ratio}x (threshold: ${THRESHOLD}x)"
+        suspicious=$((suspicious + 1))
+    else
+        echo "✓  OK: $filename (ratio: ${ratio}x)"
+        good=$((good + 1))
+    fi
+
+    count=$((count + 1))
+done
+
+echo ""
+echo "=== Summary ==="
+echo "Total files scanned: $count"
+echo "✓ Good quality: $good"
+echo "⚠️  Clicks detected: $suspicious"
+
+if [ $suspicious -gt 0 ]; then
+    echo ""
+    echo "⚠️  Warning: $suspicious file(s) have clicks."
+    echo "These files were likely encoded with the old buffer size (8)."
+    echo "Delete the cache and re-download to fix: rm -rf $CACHE_DIR/*.flac"
+    exit 1
+fi
+
+echo ""
+echo "✓ All files are good quality!"
+exit 0

detect_clicks.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+# Script pour détecter les clics dans les fichiers FLAC du cache
+
+CACHE_DIR="${1:-/tmp/pmomusic_test/audio_cache}"
+
+if [ ! -d "$CACHE_DIR" ]; then
+    echo "Error: Cache directory not found: $CACHE_DIR"
+    exit 1
+fi
+
+echo "=== FLAC Click Detection Tool ==="
+echo "Scanning: $CACHE_DIR"
+echo ""
+
+# Vérifier que sox est installé
+if ! command -v sox &> /dev/null; then
+    echo "Error: sox is not installed. Install it with: sudo apt install sox"
+    exit 1
+fi
+
+count=0
+suspicious=0
+
+for file in "$CACHE_DIR"/*.orig.flac; do
+    if [ ! -f "$file" ]; then
+        echo "No FLAC files found in $CACHE_DIR"
+        exit 0
+    fi
+
+    filename=$(basename "$file")
+    echo "Analyzing: $filename"
+
+    # Obtenir toutes les stats
+    stats=$(sox "$file" -n stat 2>&1)
+
+    # Extraire les valeurs importantes
+    pk_lev=$(echo "$stats" | grep "Pk lev dB" | awk '{print $4}')
+    rms_lev=$(echo "$stats" | grep "RMS lev dB" | awk '{print $4}')
+    crest=$(echo "$stats" | grep "Crest factor" | awk '{print $3}')
+
+    echo "  Peak level: ${pk_lev:-N/A} dB"
+    echo "  RMS level: ${rms_lev:-N/A} dB"
+    echo "  Crest factor: ${crest:-N/A} dB"
+
+    # Analyser la variance d'amplitude (détection de clics)
+    # On compte le nombre de pics au-dessus d'un seuil
+    peaks=$(sox "$file" -n stats 2>&1 | grep "Maximum amplitude" | awk '{print $3}')
+
+    if [ -n "$peaks" ]; then
+        # Si le peak est proche de 1.0 (clipping), c'est suspect
+        is_clipping=$(echo "$peaks > 0.95" | bc -l 2>/dev/null)
+        if [ "$is_clipping" = "1" ]; then
+            echo "  ⚠️  WARNING: Possible clipping detected!"
+            suspicious=$((suspicious + 1))
+        else
+            echo "  ✓  OK"
+        fi
+    else
+        echo "  ✓  OK"
+    fi
+
+    echo ""
+    count=$((count + 1))
+done
+
+echo "=== Summary ==="
+echo "Files scanned: $count"
+echo "Suspicious files: $suspicious"
+
+if [ $suspicious -gt 0 ]; then
+    echo ""
+    echo "⚠️  Some files may have issues. Listen to them carefully."
+    exit 1
+fi
+
+exit 0

docker-build.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+# Script de build Docker pour PMOMusic
+# Usage: ./docker-build.sh [OPTIONS]
+
+set -e
+
+# Couleurs pour l'affichage
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Configuration par défaut
+IMAGE_NAME="pmomusic"
+TAG="latest"
+NO_CACHE=false
+PUSH=true
+REGISTRY="niepce.petite-maison-orange.fr/public"
+
+# Fonction d'aide
+show_help() {
+    echo "Usage: $0 [OPTIONS]"
+    echo ""
+    echo "Options:"
+    echo "  -t, --tag TAG         Tag de l'image (défaut: latest)"
+    echo "  -r, --registry URL    Registry Docker (ex: ghcr.io/user)"
+    echo "  -n, --no-cache        Build sans cache"
+    echo "  -p, --push            Push l'image vers le registry"
+    echo "  -h, --help            Affiche cette aide"
+    echo ""
+    echo "Exemples:"
+    echo "  $0                                    # Build local avec tag 'latest'"
+    echo "  $0 -t v1.0.0                         # Build avec tag 'v1.0.0'"
+    echo "  $0 -t v1.0.0 -r ghcr.io/user -p      # Build et push vers GHCR"
+    echo "  $0 -n                                # Build sans cache"
+    exit 0
+}
+
+# Parsing des arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -t|--tag)
+            TAG="$2"
+            shift 2
+            ;;
+        -r|--registry)
+            REGISTRY="$2"
+            shift 2
+            ;;
+        -n|--no-cache)
+            NO_CACHE=true
+            shift
+            ;;
+        -p|--push)
+            PUSH=true
+            shift
+            ;;
+        -h|--help)
+            show_help
+            ;;
+        *)
+            echo -e "${RED}Erreur: Option inconnue '$1'${NC}"
+            show_help
+            ;;
+    esac
+done
+
+# Construire le nom complet de l'image
+if [ -n "$REGISTRY" ]; then
+    FULL_IMAGE_NAME="$REGISTRY/$IMAGE_NAME:$TAG"
+else
+    FULL_IMAGE_NAME="$IMAGE_NAME:$TAG"
+fi
+
+# Afficher la configuration
+echo -e "${GREEN}========================================${NC}"
+echo -e "${GREEN}Build Docker PMOMusic${NC}"
+echo -e "${GREEN}========================================${NC}"
+echo ""
+echo "Image: $FULL_IMAGE_NAME"
+echo "No cache: $NO_CACHE"
+echo "Push: $PUSH"
+echo ""
+
+# Construire la commande Docker
+DOCKER_CMD="docker build"
+
+if [ "$NO_CACHE" = true ]; then
+    DOCKER_CMD="$DOCKER_CMD --no-cache"
+fi
+
+DOCKER_CMD="$DOCKER_CMD --build-arg BUILD_DATE=\"$(date -u +'%Y-%m-%dT%H:%M:%SZ')\" -t $FULL_IMAGE_NAME ."
+
+# Exécuter le build
+echo -e "${YELLOW}→ Démarrage du build...${NC}"
+echo "Commande: $DOCKER_CMD"
+echo ""
+
+if eval "$DOCKER_CMD"; then
+    echo ""
+    echo -e "${GREEN}✓ Build réussi !${NC}"
+
+    # Afficher la taille de l'image
+    IMAGE_SIZE=$(docker images "$FULL_IMAGE_NAME" --format "{{.Size}}")
+    echo "Taille de l'image: $IMAGE_SIZE"
+
+    # Push si demandé
+    if [ "$PUSH" = true ]; then
+        echo ""
+        echo -e "${YELLOW}→ Push de l'image vers le registry...${NC}"
+
+        if docker push "$FULL_IMAGE_NAME"; then
+            echo -e "${GREEN}✓ Image pushée avec succès !${NC}"
+        else
+            echo -e "${RED}✗ Erreur lors du push${NC}"
+            exit 1
+        fi
+    fi
+
+    echo ""
+    echo -e "${GREEN}========================================${NC}"
+    echo -e "${GREEN}Build terminé avec succès !${NC}"
+    echo -e "${GREEN}========================================${NC}"
+    echo ""
+    echo "Pour lancer le conteneur:"
+    echo "  docker run -it --rm --network host $FULL_IMAGE_NAME"
+    echo ""
+    echo "Ou avec docker-compose:"
+    echo "  docker-compose up -d"
+
+else
+    echo ""
+    echo -e "${RED}✗ Erreur lors du build${NC}"
+    exit 1
+fi

docker-compose.yml

@@ -0,0 +1,39 @@
+version: '3.8'
+
+services:
+  pmomusic:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: pmomusic:latest
+    container_name: pmomusic
+
+    # Port mapping (adjust to your needs)
+    ports:
+      - "8080:8080"
+
+    # Volume for persistent configuration
+    volumes:
+      - ./config:/home/pmomusic/.pmomusic
+      - ./cache:/home/pmomusic/cache
+
+    # Environment variables (adjust as needed)
+    environment:
+      - RUST_LOG=info
+      # Add other environment variables here
+
+    # Network mode for UPnP/DLNA discovery (host mode for multicast)
+    network_mode: host
+
+    # Restart policy
+    restart: unless-stopped
+
+    # Resource limits (optional)
+    deploy:
+      resources:
+        limits:
+          cpus: '2.0'
+          memory: 1G
+        reservations:
+          cpus: '0.5'
+          memory: 256M

headers.txt

@@ -0,0 +1,5 @@
+HTTP/1.1 200 OK
+content-type: text/xml; charset="utf-8"
+content-length: 1593
+date: Mon, 20 Oct 2025 17:44:48 GMT
+

media_

@@ -0,0 +1,431 @@
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmoserver/src/config_ext.rs:35:5
+   |
+35 |     async fn init_config_api(&mut self) -> Result<()>;
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+   = note: `#[warn(async_fn_in_trait)]` on by default
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+35 -     async fn init_config_api(&mut self) -> Result<()>;
+35 +     fn init_config_api(&mut self) -> impl std::future::Future<Output = Result<()>> + Send;
+   |
+
+warning: `pmoserver` (lib) generated 1 warning
+warning: variable does not need to be mutable
+   --> pmocache/src/cache.rs:604:9
+    |
+604 |         mut reader: R,
+    |         ----^^^^^^
+    |         |
+    |         help: remove this `mut`
+    |
+    = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmocache/src/cache_trait.rs:97:5
+   |
+97 |     async fn add_from_url(&self, url: &str, collection: Option<&str>) -> Result<String>;
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+   = note: `#[warn(async_fn_in_trait)]` on by default
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+97 -     async fn add_from_url(&self, url: &str, collection: Option<&str>) -> Result<String>;
+97 +     fn add_from_url(&self, url: &str, collection: Option<&str>) -> impl std::future::Future<Output = Result<String>> + Send;
+   |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/cache_trait.rs:111:5
+    |
+111 |     async fn add_from_file(&self, path: &str, collection: Option<&str>) -> Result<String>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+111 -     async fn add_from_file(&self, path: &str, collection: Option<&str>) -> Result<String>;
+111 +     fn add_from_file(&self, path: &str, collection: Option<&str>) -> impl std::future::Future<Output = Result<String>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/cache_trait.rs:118:5
+    |
+118 |     async fn get(&self, pk: &str) -> Result<PathBuf>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+118 -     async fn get(&self, pk: &str) -> Result<PathBuf>;
+118 +     fn get(&self, pk: &str) -> impl std::future::Future<Output = Result<PathBuf>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/cache_trait.rs:125:5
+    |
+125 |     async fn get_collection(&self, collection: &str) -> Result<Vec<PathBuf>>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+125 -     async fn get_collection(&self, collection: &str) -> Result<Vec<PathBuf>>;
+125 +     fn get_collection(&self, collection: &str) -> impl std::future::Future<Output = Result<Vec<PathBuf>>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/cache_trait.rs:128:5
+    |
+128 |     async fn purge(&self) -> Result<()>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+128 -     async fn purge(&self) -> Result<()>;
+128 +     fn purge(&self) -> impl std::future::Future<Output = Result<()>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/cache_trait.rs:131:5
+    |
+131 |     async fn consolidate(&self) -> Result<()>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+131 -     async fn consolidate(&self) -> Result<()>;
+131 +     fn consolidate(&self) -> impl std::future::Future<Output = Result<()>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/cache_trait.rs:147:5
+    |
+147 |     async fn is_valid_pk(&self, pk: &str) -> bool {
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+147 ~     fn is_valid_pk(&self, pk: &str) -> impl std::future::Future<Output = bool> + Send {async {
+148 |         if self.get_database().get(pk, false).is_err() {
+...
+218 |         false
+219 ~     } }
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmocache/src/pmoserver_ext.rs:391:5
+    |
+391 |     async fn init_generic_cache<C: CacheConfig + 'static>(
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+391 ~     fn init_generic_cache<C: CacheConfig + 'static>(
+392 |         &mut self,
+...
+395 |         content_type: &'static str,
+396 ~     ) -> impl std::future::Future<Output = anyhow::Result<Arc<Cache<C>>>> + Send;
+    |
+
+warning: `pmocache` (lib) generated 9 warnings (run `cargo fix --lib -p pmocache` to apply 1 suggestion)
+warning: unused import: `serde_json::Value`
+  --> pmoaudiocache/src/cache.rs:11:5
+   |
+11 | use serde_json::Value;
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
+
+warning: unused import: `pmometadata::TrackMetadata`
+  --> pmoaudiocache/src/api.rs:11:5
+   |
+11 | use pmometadata::TrackMetadata;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoaudiocache/src/lib.rs:188:5
+    |
+188 |     async fn init_audio_cache(
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+    = note: `#[warn(async_fn_in_trait)]` on by default
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+188 ~     fn init_audio_cache(
+189 |         &mut self,
+190 |         cache_dir: &str,
+191 |         limit: usize,
+192 ~     ) -> impl std::future::Future<Output = anyhow::Result<std::sync::Arc<Cache>>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoaudiocache/src/lib.rs:197:5
+    |
+197 |     async fn init_audio_cache_configured(&mut self) -> anyhow::Result<std::sync::Arc<Cache>>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+197 -     async fn init_audio_cache_configured(&mut self) -> anyhow::Result<std::sync::Arc<Cache>>;
+197 +     fn init_audio_cache_configured(&mut self) -> impl std::future::Future<Output = anyhow::Result<std::sync::Arc<Cache>>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmoaudiocache/src/metadata_ext.rs:36:5
+   |
+36 |     async fn get_title(&self, pk: &str) -> anyhow::Result<Option<String>>;
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+36 -     async fn get_title(&self, pk: &str) -> anyhow::Result<Option<String>>;
+36 +     fn get_title(&self, pk: &str) -> impl std::future::Future<Output = anyhow::Result<Option<String>>> + Send;
+   |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmoaudiocache/src/metadata_ext.rs:37:5
+   |
+37 |     async fn get_artist(&self, pk: &str) -> anyhow::Result<Option<String>>;
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+37 -     async fn get_artist(&self, pk: &str) -> anyhow::Result<Option<String>>;
+37 +     fn get_artist(&self, pk: &str) -> impl std::future::Future<Output = anyhow::Result<Option<String>>> + Send;
+   |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmoaudiocache/src/metadata_ext.rs:38:5
+   |
+38 |     async fn get_album(&self, pk: &str) -> anyhow::Result<Option<String>>;
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+38 -     async fn get_album(&self, pk: &str) -> anyhow::Result<Option<String>>;
+38 +     fn get_album(&self, pk: &str) -> impl std::future::Future<Output = anyhow::Result<Option<String>>> + Send;
+   |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmoaudiocache/src/metadata_ext.rs:39:5
+   |
+39 |     async fn get_duration_secs(&self, pk: &str) -> anyhow::Result<Option<i64>>;
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+39 -     async fn get_duration_secs(&self, pk: &str) -> anyhow::Result<Option<i64>>;
+39 +     fn get_duration_secs(&self, pk: &str) -> impl std::future::Future<Output = anyhow::Result<Option<i64>>> + Send;
+   |
+
+warning: `pmoaudiocache` (lib) generated 8 warnings (run `cargo fix --lib -p pmoaudiocache` to apply 1 suggestion)
+warning: unused import: `tokio_stream::StreamExt`
+  --> pmoplaylist/src/sse.rs:16:5
+   |
+16 | use tokio_stream::StreamExt;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
+
+warning: methods `list_playlist_ids` and `remove_by_cache_pk` are never used
+   --> pmoplaylist/src/persistence/mod.rs:219:18
+    |
+ 17 | impl PersistenceManager {
+    | ----------------------- methods in this implementation
+...
+219 |     pub async fn list_playlist_ids(&self) -> Result<Vec<String>> {
+    |                  ^^^^^^^^^^^^^^^^^
+...
+240 |     pub async fn remove_by_cache_pk(&self, cache_pk: &str) -> Result<()> {
+    |                  ^^^^^^^^^^^^^^^^^^
+    |
+    = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
+
+warning: function `PlaylistManager` should have a snake case name
+   --> pmoplaylist/src/manager.rs:620:8
+    |
+620 | pub fn PlaylistManager() -> &'static PlaylistManager {
+    |        ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `playlist_manager`
+    |
+    = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
+
+warning: `pmoplaylist` (lib) generated 3 warnings
+warning: unused variable: `base_url`
+   --> pmoupnp/src/upnp_server.rs:306:13
+    |
+306 |         let base_url = self.info().base_url.clone();
+    |             ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_base_url`
+    |
+    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoupnp/src/upnp_api.rs:229:5
+    |
+229 |     async fn register_upnp_api(&mut self);
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+    = note: `#[warn(async_fn_in_trait)]` on by default
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+229 -     async fn register_upnp_api(&mut self);
+229 +     fn register_upnp_api(&mut self) -> impl std::future::Future<Output = ()> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+  --> pmoupnp/src/upnp_server.rs:96:5
+   |
+96 |     async fn register_device(
+   |     ^^^^^
+   |
+   = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+   |
+96 ~     fn register_device(
+97 |         &mut self,
+98 |         device: Arc<Device>,
+99 ~     ) -> impl std::future::Future<Output = Result<Arc<DeviceInstance>, DeviceError>> + Send;
+   |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoupnp/src/upnp_server.rs:125:5
+    |
+125 |     async fn init_cover_cache(
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+125 ~     fn init_cover_cache(
+126 |         &mut self,
+127 |         cache_dir: &str,
+128 |         limit: usize,
+129 ~     ) -> impl std::future::Future<Output = Result<Arc<CoverCache>, anyhow::Error>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoupnp/src/upnp_server.rs:144:5
+    |
+144 |     async fn init_audio_cache(
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+144 ~     fn init_audio_cache(
+145 |         &mut self,
+146 |         cache_dir: &str,
+147 |         limit: usize,
+148 ~     ) -> impl std::future::Future<Output = Result<Arc<AudioCache>, anyhow::Error>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoupnp/src/upnp_server.rs:158:5
+    |
+158 |     async fn init_caches(&mut self) -> Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+158 -     async fn init_caches(&mut self) -> Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error>;
+158 +     fn init_caches(&mut self) -> impl std::future::Future<Output = Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error>> + Send;
+    |
+
+warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
+   --> pmoupnp/src/upnp_server.rs:225:5
+    |
+225 |     async fn create_upnp_server() -> Result<Arc<tokio::sync::RwLock<Server>>, anyhow::Error>;
+    |     ^^^^^
+    |
+    = note: you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
+help: you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
+    |
+225 -     async fn create_upnp_server() -> Result<Arc<tokio::sync::RwLock<Server>>, anyhow::Error>;
+225 +     fn create_upnp_server() -> impl std::future::Future<Output = Result<Arc<tokio::sync::RwLock<Server>>, anyhow::Error>> + Send;
+    |
+
+warning: `pmoupnp` (lib) generated 7 warnings
+    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.16s
+     Running `target/debug/examples/media_server_events_demo`
+ControlPoint started; waiting 5s for discovery...
+Discovered media servers:
+  - BubbleUPnP Media Server (SM-A536B) | model=BubbleUPnP Media Server | udn=uuid:d38a2dc7-13c1-4a39-ab36-513490cf6766 | location=http://192.168.0.98:58645/dev/d38a2dc7-13c1-4a39-ab36-513490cf6766/desc.xml
+  - fenice | model=Jellyfin Server | udn=uuid:526dedec-fde2-4224-bac6-06f7b11711cf | location=http://192.168.0.34:8096/dlna/526dedec-fde2-4224-bac6-06f7b11711cf/description.xml
+  - PMOMusic Media Server | model=PMOMusic Media Server | udn=uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4 | location=http://192.168.0.138:8080/device/17fe2ea6-8908-4e30-bc52-b28ea4cab3e4/desc.xml
+  - Freebox Server | model=Freebox Media Server | udn=uuid:e929a46e-d218-377d-2dde-32bd8080dfbf | location=http://192.168.0.254:52424/device.xml
+Listening for ContentDirectory events for 90 seconds...
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=27)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:history
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=28)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=30)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=31)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=32)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=33)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=37)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=40)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=41)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=42)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=44)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=45)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=46)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:main:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=49)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=50)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=51)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=52)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=53)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=54)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=55)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=56)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=57)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=59)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=63)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=64)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=65)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=66)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=67)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=68)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Global content update (SystemUpdateID=69)
+[PMOMusic Media Server (uuid:17fe2ea6-8908-4e30-bc52-b28ea4cab3e4)] Containers updated: radio-paradise:channel:rock:liveplaylist
+Monitoring finished.

old_code/pmoaudio/examples/multiroom_demo.rs

@@ -0,0 +1,80 @@
+//! Exemple de configuration multiroom avec BufferNode
+//!
+//! Démontre l'utilisation du buffer circulaire pour synchroniser
+//! plusieurs sorties avec des délais différents
+
+use pmoaudio::{BufferNode, SinkNode, SourceNode};
+
+#[tokio::main]
+async fn main() {
+    println!("=== Multiroom Demo ===\n");
+
+    // Buffer avec capacité pour gérer les délais
+    let (buffer, buffer_tx) = BufferNode::new(50, 10);
+
+    // Créer 3 sorties avec délais différents
+    let (sink1, sink1_tx) = SinkNode::new("Room 1 (no delay)".to_string(), 10);
+    let (sink2, sink2_tx) = SinkNode::new("Room 2 (5 chunks delay)".to_string(), 10);
+    let (sink3, sink3_tx) = SinkNode::new("Room 3 (10 chunks delay)".to_string(), 10);
+
+    buffer.add_subscriber_with_offset(sink1_tx, 0).await;
+    buffer.add_subscriber_with_offset(sink2_tx, 5).await;
+    buffer.add_subscriber_with_offset(sink3_tx, 10).await;
+
+    // Spawn buffer et sinks
+    tokio::spawn(async move {
+        buffer.run().await.unwrap();
+    });
+
+    let sink1_handle = tokio::spawn(async move {
+        let stats = sink1.run_with_stats().await.unwrap();
+        stats.display();
+        stats
+    });
+
+    let sink2_handle = tokio::spawn(async move {
+        let stats = sink2.run_with_stats().await.unwrap();
+        stats.display();
+        stats
+    });
+
+    let sink3_handle = tokio::spawn(async move {
+        let stats = sink3.run_with_stats().await.unwrap();
+        stats.display();
+        stats
+    });
+
+    // Générer de l'audio dans une tâche séparée
+    println!("Generating audio for multiroom playback...\n");
+    tokio::spawn(async move {
+        let mut source = SourceNode::new();
+        source.add_subscriber(buffer_tx);
+        source
+            .generate_chunks(30, 4800, 48000, 440.0)
+            .await
+            .unwrap();
+    });
+
+    println!("Waiting for all rooms to finish...\n");
+
+    // Attendre toutes les sorties
+    let stats1 = sink1_handle.await.unwrap();
+    let stats2 = sink2_handle.await.unwrap();
+    let stats3 = sink3_handle.await.unwrap();
+
+    println!("\n=== Multiroom Summary ===");
+    println!(
+        "{}: {} chunks received",
+        stats1.name, stats1.chunks_received
+    );
+    println!(
+        "{}: {} chunks received",
+        stats2.name, stats2.chunks_received
+    );
+    println!(
+        "{}: {} chunks received",
+        stats3.name, stats3.chunks_received
+    );
+
+    println!("\nNote: Delayed rooms receive fewer chunks due to the offset");
+}

old_code/pmoaudio/examples/multiroom_volume_demo.rs

@@ -0,0 +1,168 @@
+//! Exemple complet de pipeline multiroom avec contrôle de volume
+//!
+//! Ce programme démontre :
+//! - Une source audio unique
+//! - Deux branches de sortie : Chromecast et DiskSink
+//! - Un volume master avec deux VolumeNodes secondaires synchronisés
+//! - Système d'événements pour la communication entre nodes
+
+use pmoaudio::{
+    ChromecastConfig, ChromecastSink, DiskSink, DiskSinkConfig, SourceNode, VolumeNode,
+};
+use tokio::sync::mpsc;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== PMOAudio Multiroom Volume Demo ===\n");
+
+    // Configuration
+    let sample_rate = 48000u32;
+    let chunk_size = 4800usize; // 100ms à 48kHz
+    let num_chunks = 50; // 5 secondes de lecture
+    let frequency = 440.0; // La 440 Hz
+
+    // ===== 1. Créer la source audio =====
+    println!("1. Creating audio source...");
+    let mut source = SourceNode::new();
+
+    // ===== 2. Créer le volume master =====
+    println!("2. Creating master volume node...");
+    let (mut master_volume, master_tx) = VolumeNode::new("master".to_string(), 1.0, 50);
+    let master_handle = master_volume.get_handle();
+
+    // Channel pour les événements du volume master
+    let (master_event_tx, master_event_rx_chromecast) = mpsc::channel(10);
+    let (_, master_event_rx_disk) = mpsc::channel(10);
+
+    master_volume.subscribe_volume_events(master_event_tx);
+
+    source.add_subscriber(master_tx);
+
+    // ===== 3. Créer les branches de sortie =====
+
+    // Branche 1: Chromecast avec volume secondaire
+    println!("3a. Creating Chromecast output branch...");
+    let (mut chromecast_volume, chromecast_volume_tx) =
+        VolumeNode::new("chromecast_volume".to_string(), 0.8, 50);
+
+    chromecast_volume.set_master_volume_source(master_event_rx_chromecast);
+
+    let chromecast_config = ChromecastConfig {
+        device_address: "192.168.1.100".to_string(),
+        device_name: "Living Room".to_string(),
+        ..Default::default()
+    };
+
+    let (chromecast_sink, chromecast_sink_tx) =
+        ChromecastSink::new("chromecast1".to_string(), chromecast_config, 50);
+
+    chromecast_volume.add_subscriber(chromecast_sink_tx);
+    master_volume.add_subscriber(chromecast_volume_tx);
+
+    // Branche 2: DiskSink avec volume secondaire
+    println!("3b. Creating DiskSink output branch...");
+    let (mut disk_volume, disk_volume_tx) = VolumeNode::new("disk_volume".to_string(), 0.9, 50);
+
+    disk_volume.set_master_volume_source(master_event_rx_disk);
+
+    let disk_config = DiskSinkConfig {
+        output_dir: std::env::temp_dir().join("pmoaudio_demo"),
+        filename: Some("multiroom_output.wav".to_string()),
+        ..Default::default()
+    };
+
+    let (disk_sink, disk_sink_tx) = DiskSink::new("disk1".to_string(), disk_config, 50);
+
+    disk_volume.add_subscriber(disk_sink_tx);
+    master_volume.add_subscriber(disk_volume_tx);
+
+    // ===== 4. Lancer tous les nodes =====
+    println!("4. Starting pipeline nodes...\n");
+
+    // Spawn master volume
+    let master_volume_handle = tokio::spawn(async move {
+        master_volume.run().await.unwrap();
+    });
+
+    // Spawn chromecast branch
+    let chromecast_volume_handle = tokio::spawn(async move {
+        chromecast_volume.run().await.unwrap();
+    });
+
+    let chromecast_sink_handle = tokio::spawn(async move {
+        let stats = chromecast_sink.run().await.unwrap();
+        stats.display();
+    });
+
+    // Spawn disk branch
+    let disk_volume_handle = tokio::spawn(async move {
+        disk_volume.run().await.unwrap();
+    });
+
+    let disk_sink_handle = tokio::spawn(async move {
+        let stats = disk_sink.run().await.unwrap();
+        stats.display();
+    });
+
+    // ===== 5. Contrôler le volume pendant la lecture =====
+    let master_handle_clone = master_handle.clone();
+    tokio::spawn(async move {
+        // Attendre un peu, puis diminuer le volume
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+        println!("\n>>> Decreasing master volume to 0.7");
+        master_handle_clone.set_volume(0.7).await;
+
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+        println!(">>> Decreasing master volume to 0.4");
+        master_handle_clone.set_volume(0.4).await;
+
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+        println!(">>> Increasing master volume back to 1.0");
+        master_handle_clone.set_volume(1.0).await;
+    });
+
+    // ===== 6. Générer et envoyer les chunks audio =====
+    println!("5. Generating and streaming audio...");
+    tokio::spawn(async move {
+        source
+            .generate_chunks(num_chunks, chunk_size, sample_rate, frequency)
+            .await
+            .unwrap();
+        println!("\n>>> Audio generation complete!");
+    });
+
+    // ===== 7. Attendre la fin de tous les nodes =====
+    println!("6. Waiting for all nodes to complete...\n");
+
+    // Attendre que les sinks terminent
+    chromecast_sink_handle.await?;
+    disk_sink_handle.await?;
+
+    // Nettoyer
+    master_volume_handle.abort();
+    chromecast_volume_handle.abort();
+    disk_volume_handle.abort();
+
+    println!("\n=== Demo completed successfully! ===");
+    println!("\nSummary:");
+    println!(
+        "- Generated {} chunks of {} samples each",
+        num_chunks, chunk_size
+    );
+    println!(
+        "- Total duration: {:.2} seconds",
+        (num_chunks as usize * chunk_size) as f32 / sample_rate as f32
+    );
+    println!("- Output to Chromecast: Living Room (192.168.1.100)");
+    println!(
+        "- Output to file: {}",
+        std::env::temp_dir()
+            .join("pmoaudio_demo")
+            .join("multiroom_output.wav")
+            .display()
+    );
+    println!("- Master volume control demonstrated with live changes");
+    println!("\nAll streams received synchronized volume updates!");
+
+    Ok(())
+}

old_code/pmoaudio/examples/pipeline_demo.rs

@@ -0,0 +1,126 @@
+//! Exemple de pipeline audio stéréo complet avec tous les nodes
+//!
+//! Pipeline: SourceNode → DecoderNode → DspNode → BufferNode → TimerNode → SinkNode(s)
+
+use pmoaudio::{BufferNode, DecoderNode, DspNode, SinkNode, SourceNode, TimerNode};
+
+#[tokio::main]
+async fn main() {
+    println!("=== PMOAudio Pipeline Demo ===\n");
+
+    // Créer le pipeline de nodes
+
+    // 2. DecoderNode - passthrough dans cet exemple
+    let (mut decoder, decoder_tx) = DecoderNode::new(10);
+
+    // 3. DspNode - applique un gain de 0.5
+    let (mut dsp, dsp_tx) = DspNode::new(10, 0.5);
+
+    // 4. BufferNode - buffer circulaire pour multiroom
+    let (mut buffer, buffer_tx) = BufferNode::new(100, 10);
+
+    // 5. TimerNode - calcule la position temporelle
+    let (mut timer, timer_tx) = TimerNode::new(10);
+
+    // 6. SinkNodes - deux destinations finales
+    let (sink1, sink1_tx) = SinkNode::new("Main Output".to_string(), 10);
+    let (sink2, sink2_tx) = SinkNode::new("Secondary Output".to_string(), 10);
+
+    // Ajouter un abonné au BufferNode avec offset (multiroom simulation)
+    let (sink3, sink3_tx) = SinkNode::new("Delayed Output".to_string(), 10);
+    buffer.add_subscriber_with_offset(sink3_tx, 5).await; // 5 chunks de retard
+
+    // Connecter le pipeline
+    decoder.add_subscriber(dsp_tx);
+    dsp.add_subscriber(buffer_tx);
+    buffer.add_next_subscriber(timer_tx); // BufferNode -> TimerNode
+    timer.add_subscriber(sink1_tx);
+    timer.add_subscriber(sink2_tx);
+
+    // Obtenir un handle pour lire la position du TimerNode
+    let timer_handle = timer.get_position_handle();
+
+    // Spawn tous les nodes
+    let decoder_handle = tokio::spawn(async move {
+        decoder.run_passthrough().await.unwrap();
+    });
+
+    let dsp_handle = tokio::spawn(async move {
+        dsp.run().await.unwrap();
+    });
+
+    let buffer_handle = tokio::spawn(async move {
+        buffer.run().await.unwrap();
+    });
+
+    let timer_handle_task = tokio::spawn(async move {
+        timer.run().await.unwrap();
+    });
+
+    let sink1_handle = tokio::spawn(async move {
+        let stats = sink1.run_with_stats().await.unwrap();
+        stats.display();
+        stats
+    });
+
+    let sink2_handle = tokio::spawn(async move {
+        sink2.run_silent().await.unwrap();
+    });
+
+    let sink3_handle = tokio::spawn(async move {
+        let stats = sink3.run_with_stats().await.unwrap();
+        stats.display();
+        stats
+    });
+
+    // Spawn une tâche pour afficher la position périodiquement
+    let position_monitor = tokio::spawn(async move {
+        for _ in 0..10 {
+            tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+            let position = timer_handle.position_sec().await;
+            let samples = timer_handle.elapsed_samples().await;
+            println!("Position: {:.3} sec ({} samples)", position, samples);
+        }
+    });
+
+    // Générer des chunks audio
+    println!("Generating audio chunks...\n");
+    let chunk_size = 4800; // 100ms à 48kHz
+    let sample_rate = 48000;
+    let frequency = 440.0; // La 440Hz
+
+    // Source node dans une tâche séparée
+    tokio::spawn(async move {
+        let mut source = SourceNode::new();
+        source.add_subscriber(decoder_tx);
+
+        // Générer 50 chunks (environ 5 secondes)
+        source
+            .generate_chunks(50, chunk_size, sample_rate, frequency)
+            .await
+            .unwrap();
+
+        println!("\nChunks sent. Processing...\n");
+    });
+
+    // Attendre que tous les nodes terminent
+    decoder_handle.await.unwrap();
+    dsp_handle.await.unwrap();
+    buffer_handle.await.unwrap();
+    timer_handle_task.await.unwrap();
+
+    let stats1 = sink1_handle.await.unwrap();
+    sink2_handle.await.unwrap();
+    let stats3 = sink3_handle.await.unwrap();
+    position_monitor.await.unwrap();
+
+    println!("\n=== Pipeline Demo Complete ===");
+    println!(
+        "Main output processed: {} chunks, {:.3} sec",
+        stats1.chunks_received, stats1.total_duration_sec
+    );
+    println!(
+        "Delayed output processed: {} chunks, {:.3} sec",
+        stats3.chunks_received, stats3.total_duration_sec
+    );
+}

old_code/pmoaudio/examples/quick_start.rs

@@ -0,0 +1,96 @@
+//! Quick Start - Démonstration rapide des nouvelles fonctionnalités
+//!
+//! Cet exemple montre l'utilisation des principales nouvelles fonctionnalités :
+//! - VolumeNode avec contrôle dynamique
+//! - DiskSink pour écriture sur disque
+//! - Pipeline simple et efficace
+
+use pmoaudio::{AudioFileFormat, DiskSink, DiskSinkConfig, SourceNode, VolumeNode};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== PMOAudio Quick Start ===\n");
+
+    // 1. Créer la source audio (génère un signal de test)
+    let mut source = SourceNode::new();
+
+    // 2. Créer un VolumeNode pour contrôler le volume
+    let (mut volume, volume_tx) = VolumeNode::new("main".to_string(), 0.8, 10);
+    let volume_handle = volume.get_handle();
+
+    // 3. Créer un DiskSink pour écrire sur disque
+    let output_dir = std::env::temp_dir().join("pmoaudio_quickstart");
+    let config = DiskSinkConfig {
+        output_dir: output_dir.clone(),
+        filename: Some("quickstart_output.wav".to_string()),
+        format: AudioFileFormat::Wav,
+        buffer_size: 50,
+    };
+
+    let (disk_sink, disk_tx) = DiskSink::new("disk".to_string(), config, 10);
+
+    // 4. Connecter le pipeline : Source → Volume → DiskSink
+    source.add_subscriber(volume_tx);
+    volume.add_subscriber(disk_tx);
+
+    println!("Pipeline configured:");
+    println!("  SourceNode → VolumeNode (vol=0.8) → DiskSink");
+    println!("  Output: {}/quickstart_output.wav\n", output_dir.display());
+
+    // 5. Lancer les nodes
+    let volume_handle_clone = volume_handle.clone();
+    tokio::spawn(async move {
+        volume.run().await.unwrap();
+    });
+
+    let disk_handle = tokio::spawn(async move {
+        let stats = disk_sink.run().await.unwrap();
+        println!("\nDiskSink Statistics:");
+        stats.display();
+        stats
+    });
+
+    // 6. Démonstration du contrôle de volume pendant la lecture
+    tokio::spawn(async move {
+        println!("Generating audio with volume changes...");
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        println!("  → Volume: 0.8 (initial)");
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        volume_handle_clone.set_volume(0.5).await;
+        println!("  → Volume: 0.5 (decreased)");
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        volume_handle_clone.set_volume(1.0).await;
+        println!("  → Volume: 1.0 (maximum)");
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        volume_handle_clone.set_volume(0.3).await;
+        println!("  → Volume: 0.3 (low)");
+    });
+
+    // 7. Générer l'audio (10 chunks de 4800 samples à 48kHz = ~1 seconde)
+    source
+        .generate_chunks(
+            10,    // nombre de chunks
+            4800,  // samples par chunk (100ms @ 48kHz)
+            48000, // sample rate
+            440.0, // fréquence (La 440 Hz)
+        )
+        .await?;
+
+    // 8. Attendre la fin du traitement
+    let stats = disk_handle.await?;
+
+    // 9. Résumé
+    println!("\n=== Summary ===");
+    println!("✓ Audio file generated successfully");
+    println!("✓ {} chunks written", stats.chunks_written);
+    println!("✓ Duration: {:.2} seconds", stats.total_duration_sec);
+    println!("✓ Volume was dynamically adjusted during playback");
+    println!("\nYou can play the file with:");
+    println!("  ffplay {}/quickstart_output.wav", output_dir.display());
+
+    Ok(())
+}

old_code/pmoaudio/examples/simple_pipeline.rs

@@ -0,0 +1,53 @@
+//! Exemple simple de pipeline audio : Source → Timer → Sink
+//!
+//! Démontre l'utilisation basique du pipeline avec calcul de position
+
+use pmoaudio::{SinkNode, SourceNode, TimerNode};
+
+#[tokio::main]
+async fn main() {
+    println!("=== Simple Pipeline Example ===\n");
+
+    // Créer les nodes
+    let (mut timer, timer_tx) = TimerNode::new(10);
+    let (sink, sink_tx) = SinkNode::new("Output".to_string(), 10);
+
+    // Connecter
+    timer.add_subscriber(sink_tx);
+
+    // Handle pour monitorer la position
+    let timer_handle = timer.get_position_handle();
+
+    // Spawn timer et sink
+    tokio::spawn(async move {
+        timer.run().await.unwrap();
+    });
+
+    let sink_handle = tokio::spawn(async move {
+        let stats = sink.run_with_stats().await.unwrap();
+        stats.display();
+        stats
+    });
+
+    // Générer quelques secondes d'audio dans une tâche séparée
+    println!("Generating 440Hz sine wave...\n");
+
+    tokio::spawn(async move {
+        let mut source = SourceNode::new();
+        source.add_subscriber(timer_tx);
+
+        source
+            .generate_chunks(30, 4800, 48000, 440.0) // ~3 secondes
+            .await
+            .unwrap();
+
+        // La source est drop ici, fermant le channel
+    });
+
+    // Attendre la fin
+    let stats = sink_handle.await.unwrap();
+
+    let final_position = timer_handle.position_sec().await;
+    println!("\nFinal position: {:.3} seconds", final_position);
+    println!("Total duration: {:.3} seconds", stats.total_duration_sec);
+}

old_code/pmoaudio/examples/streaming_demo.rs

@@ -0,0 +1,52 @@
+//! Exemple de streaming audio en temps réel
+//!
+//! Démontre l'utilisation du pipeline avec génération de chunks
+//! en temps réel avec timing approprié
+
+use pmoaudio::{SinkNode, SourceNode, TimerNode};
+
+#[tokio::main]
+async fn main() {
+    println!("=== Streaming Demo ===\n");
+    println!("Streaming audio in real-time for 3 seconds...\n");
+
+    let mut source = SourceNode::new();
+    let (mut timer, timer_tx) = TimerNode::new(20);
+    let (sink, sink_tx) = SinkNode::new("Streaming Output".to_string(), 20);
+
+    source.add_subscriber(timer_tx);
+    timer.add_subscriber(sink_tx);
+
+    let timer_handle = timer.get_position_handle();
+
+    // Spawn le pipeline
+    tokio::spawn(async move {
+        timer.run().await.unwrap();
+    });
+
+    let sink_handle = tokio::spawn(async move {
+        sink.run_with_logging().await.unwrap();
+    });
+
+    // Monitor la position
+    let monitor_handle = tokio::spawn(async move {
+        for _ in 0..15 {
+            tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+            let position = timer_handle.position_sec().await;
+            println!("Playback position: {:.3} sec", position);
+        }
+    });
+
+    // Stream des chunks avec timing réel
+    // 100ms par chunk à 48kHz = 4800 samples
+    source
+        .stream_chunks(4800, 48000, 440.0, 3000) // 3 secondes
+        .await
+        .unwrap();
+
+    println!("\nStreaming complete.");
+
+    // Attendre la fin
+    sink_handle.await.unwrap();
+    monitor_handle.await.unwrap();
+}

old_code/pmoaudio/examples/volume_control_demo.rs

@@ -0,0 +1,58 @@
+//! Exemple simple de contrôle de volume
+//!
+//! Démontre l'utilisation du VolumeNode avec changements dynamiques
+
+use pmoaudio::{SinkNode, SourceNode, VolumeNode};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== Volume Control Demo ===\n");
+
+    // Créer la source
+    let mut source = SourceNode::new();
+
+    // Créer le volume node
+    let (mut volume, volume_tx) = VolumeNode::new("main".to_string(), 1.0, 10);
+    let volume_handle = volume.get_handle();
+
+    // Créer le sink
+    let (sink, sink_tx) = SinkNode::new("Output".to_string(), 10);
+
+    // Connecter le pipeline
+    source.add_subscriber(volume_tx);
+    volume.add_subscriber(sink_tx);
+
+    // Lancer les nodes
+    tokio::spawn(async move { volume.run().await.unwrap() });
+
+    let sink_handle = tokio::spawn(async move { sink.run_with_stats().await.unwrap() });
+
+    // Contrôler le volume pendant la lecture
+    let volume_control = tokio::spawn(async move {
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        println!("Setting volume to 0.5");
+        volume_handle.set_volume(0.5).await;
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        println!("Setting volume to 0.2");
+        volume_handle.set_volume(0.2).await;
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        println!("Setting volume to 1.0");
+        volume_handle.set_volume(1.0).await;
+    });
+
+    // Générer l'audio
+    source
+        .generate_chunks(20, 4800, 48000, 440.0)
+        .await
+        .unwrap();
+
+    volume_control.await?;
+    let stats = sink_handle.await?;
+
+    println!("\nFinal statistics:");
+    stats.display();
+
+    Ok(())
+}

old_code/pmoaudio/nodes/buffer_node.rs

@@ -0,0 +1,245 @@
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioSegment,
+};
+use std::collections::VecDeque;
+use std::sync::Arc;
+use tokio::sync::{mpsc, RwLock};
+
+/// Subscriber avec son propre offset dans le buffer
+struct BufferSubscriber {
+    tx: mpsc::Sender<Arc<AudioSegment>>,
+    offset: usize, // Position dans le buffer circulaire
+}
+
+/// BufferNode avec buffer circulaire pour support multiroom
+///
+/// Ce node maintient un buffer circulaire de chunks et permet à plusieurs
+/// abonnés de lire avec des offsets différents, ce qui est idéal pour des
+/// configurations multiroom où différentes pièces peuvent avoir un léger
+/// délai de synchronisation.
+///
+/// # Fonctionnement
+///
+/// - Le buffer est implémenté avec un `VecDeque` de taille fixe
+/// - Chaque abonné peut avoir un offset indépendant (en nombre de chunks)
+/// - Utilise `try_send` pour éviter de bloquer si un abonné est saturé
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::{BufferNode, SinkNode};
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let (buffer, buffer_tx) = BufferNode::new(50, 10);
+///
+///     let (sink1, sink1_tx) = SinkNode::new("Room 1".to_string(), 10);
+///     let (sink2, sink2_tx) = SinkNode::new("Room 2".to_string(), 10);
+///
+///     // Room 1 sans délai
+///     buffer.add_subscriber_with_offset(sink1_tx, 0).await;
+///
+///     // Room 2 avec 5 chunks de retard
+///     buffer.add_subscriber_with_offset(sink2_tx, 5).await;
+///
+///     tokio::spawn(async move { buffer.run().await.unwrap() });
+///     // ... spawn sinks et source
+/// }
+/// ```
+pub struct BufferNode {
+    buffer: Arc<RwLock<VecDeque<Arc<AudioSegment>>>>,
+    subscribers: Arc<RwLock<Vec<BufferSubscriber>>>,
+    buffer_size: usize,
+    rx: mpsc::Receiver<Arc<AudioSegment>>,
+    next_subscribers: MultiSubscriberNode, // Pour passer au node suivant
+}
+
+impl BufferNode {
+    /// Crée un nouveau BufferNode
+    ///
+    /// # Arguments
+    /// * `buffer_size` - Taille maximale du buffer circulaire
+    /// * `channel_size` - Taille du channel bounded pour backpressure
+    pub fn new(buffer_size: usize, channel_size: usize) -> (Self, mpsc::Sender<Arc<AudioSegment>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let node = Self {
+            buffer: Arc::new(RwLock::new(VecDeque::with_capacity(buffer_size))),
+            subscribers: Arc::new(RwLock::new(Vec::new())),
+            buffer_size,
+            rx,
+            next_subscribers: MultiSubscriberNode::new(),
+        };
+
+        (node, tx)
+    }
+
+    /// Ajoute un abonné avec un offset spécifique (pour multiroom)
+    pub async fn add_subscriber_with_offset(
+        &self,
+        tx: mpsc::Sender<Arc<AudioSegment>>,
+        offset: usize,
+    ) {
+        let mut subs = self.subscribers.write().await;
+        subs.push(BufferSubscriber { tx, offset });
+    }
+
+    /// Ajoute un abonné sans offset (commence au chunk courant)
+    pub async fn add_subscriber(&self, tx: mpsc::Sender<Arc<AudioSegment>>) {
+        self.add_subscriber_with_offset(tx, 0).await;
+    }
+
+    /// Ajoute un abonné pour le node suivant (sans buffer)
+    pub fn add_next_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioSegment>>) {
+        self.next_subscribers.add_subscriber(tx);
+    }
+
+    /// Démarre la boucle de traitement du BufferNode
+    pub async fn run(mut self) -> Result<(), AudioError> {
+        let mut chunk_index = 0usize;
+
+        while let Some(chunk) = self.rx.recv().await {
+            // Ajouter au buffer circulaire
+            {
+                let mut buffer = self.buffer.write().await;
+                if buffer.len() >= self.buffer_size {
+                    buffer.pop_front();
+                }
+                buffer.push_back(chunk.clone());
+            }
+
+            // Envoyer aux abonnés avec offset
+            {
+                let buffer = self.buffer.read().await;
+                let mut subs = self.subscribers.write().await;
+
+                for sub in subs.iter_mut() {
+                    // Calculer l'index dans le buffer en fonction de l'offset
+                    let target_index = if chunk_index >= sub.offset {
+                        chunk_index - sub.offset
+                    } else {
+                        continue; // Pas encore assez de données
+                    };
+
+                    // Vérifier si le chunk est disponible dans le buffer
+                    let buffer_age = chunk_index - target_index;
+                    if buffer_age < buffer.len() {
+                        let chunk_to_send = &buffer[buffer.len() - buffer_age - 1];
+                        // try_send non-bloquant pour éviter de bloquer la source
+                        let _ = sub.tx.try_send(chunk_to_send.clone());
+                    }
+                }
+            }
+
+            // Push vers les nodes suivants sans buffer
+            self.next_subscribers.try_push(chunk).await?;
+
+            chunk_index += 1;
+        }
+
+        Ok(())
+    }
+
+    /// Version avec push synchrone au lieu de try_push
+    pub async fn run_blocking(mut self) -> Result<(), AudioError> {
+        let mut chunk_index = 0usize;
+
+        while let Some(chunk) = self.rx.recv().await {
+            // Ajouter au buffer circulaire
+            {
+                let mut buffer = self.buffer.write().await;
+                if buffer.len() >= self.buffer_size {
+                    buffer.pop_front();
+                }
+                buffer.push_back(chunk.clone());
+            }
+
+            // Envoyer aux abonnés avec offset
+            {
+                let buffer = self.buffer.read().await;
+                let subs = self.subscribers.read().await;
+
+                for sub in subs.iter() {
+                    let target_index = if chunk_index >= sub.offset {
+                        chunk_index - sub.offset
+                    } else {
+                        continue;
+                    };
+
+                    let buffer_age = chunk_index - target_index;
+                    if buffer_age < buffer.len() {
+                        let chunk_to_send = &buffer[buffer.len() - buffer_age - 1];
+                        let _ = sub.tx.send(chunk_to_send.clone()).await;
+                    }
+                }
+            }
+
+            // Push vers les nodes suivants
+            for _ in 0..self.next_subscribers.subscribers.len() {
+                self.next_subscribers.push(chunk.clone()).await?;
+            }
+
+            chunk_index += 1;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_buffer_node_basic() {
+        let (mut node, tx) = BufferNode::new(10, 5);
+        let (out_tx, mut out_rx) = mpsc::channel(5);
+
+        node.add_next_subscriber(out_tx);
+
+        // Spawn le node
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer des chunks
+        for i in 0..3 {
+            let chunk = AudioSegment::AudioChunk(AudioChunk::new(i, vec![[0i32; 2]; 100], 48000, BitDepth::B24));
+            tx.send(chunk).await.unwrap();
+        }
+
+        // Recevoir les chunks
+        for i in 0..3 {
+            let chunk = out_rx.recv().await.unwrap();
+            assert_eq!(chunk.order(), i);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_buffer_node_with_offset() {
+        let (node, tx) = BufferNode::new(10, 10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        // Ajouter un abonné avec offset de 2 chunks
+        node.add_subscriber_with_offset(out_tx, 2).await;
+
+        // Spawn le node
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer 5 chunks
+        for i in 0..5 {
+            let chunk = AudioSegment::new(i, vec![[0i32; 2]; 100], 48000, BitDepth::B24);
+            tx.send(chunk).await.unwrap();
+        }
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        // L'abonné devrait recevoir les chunks 0, 1, 2 (avec 2 chunks de retard)
+        let chunk = out_rx.try_recv().unwrap();
+        assert_eq!(chunk.order(), 0);
+    }
+}

old_code/pmoaudio/nodes/chromecast_sink.rs

@@ -0,0 +1,290 @@
+//! ChromecastSink - Diffuse le flux audio vers un périphérique Chromecast
+//!
+//! Ce module fournit un sink qui envoie le flux audio à un Chromecast.
+//! Note: Cette implémentation est une version mock/skeleton. Une vraie implémentation
+//! nécessiterait une bibliothèque comme `rust-cast` ou similaire.
+
+use crate::{nodes::AudioError, AudioChunk};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// Configuration pour le ChromecastSink
+#[derive(Debug, Clone)]
+pub struct ChromecastConfig {
+    /// Nom ou adresse IP du Chromecast
+    pub device_address: String,
+
+    /// Nom amical du device
+    pub device_name: String,
+
+    /// Port de communication (défaut: 8009)
+    pub port: u16,
+
+    /// Taille du buffer de streaming
+    pub buffer_size: usize,
+
+    /// Format d'encodage pour le streaming
+    pub encoding: StreamEncoding,
+}
+
+impl Default for ChromecastConfig {
+    fn default() -> Self {
+        Self {
+            device_address: "192.168.1.100".to_string(),
+            device_name: "Living Room".to_string(),
+            port: 8009,
+            buffer_size: 50,
+            encoding: StreamEncoding::Mp3,
+        }
+    }
+}
+
+/// Formats d'encodage supportés pour le streaming
+#[derive(Debug, Clone, Copy)]
+pub enum StreamEncoding {
+    /// MP3 (compatible avec la plupart des Chromecasts)
+    Mp3,
+    /// AAC
+    Aac,
+    /// Opus
+    Opus,
+    /// PCM non compressé (haute qualité, bande passante élevée)
+    Pcm,
+}
+
+/// ChromecastSink - Diffuse vers un périphérique Chromecast
+///
+/// Ce sink encode le flux audio et le streame vers un Chromecast.
+/// La connexion est établie lors de l'initialisation et maintenue pendant toute la durée.
+///
+/// # Implémentation actuelle
+///
+/// Cette version est un mock qui simule l'envoi au Chromecast.
+/// Pour une vraie implémentation, il faudrait:
+/// - Utiliser une bibliothèque comme `rust-cast`
+/// - Établir une connexion TLS avec le device
+/// - Lancer une application de récepteur sur le Chromecast
+/// - Encoder l'audio dans le format approprié
+/// - Streamer via HTTP ou WebSocket
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::{ChromecastSink, ChromecastConfig};
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let config = ChromecastConfig {
+///         device_address: "192.168.1.100".to_string(),
+///         device_name: "Living Room".to_string(),
+///         ..Default::default()
+///     };
+///
+///     let (sink, sink_tx) = ChromecastSink::new("chromecast1".to_string(), config, 10);
+///
+///     tokio::spawn(async move {
+///         sink.run().await.unwrap()
+///     });
+/// }
+/// ```
+pub struct ChromecastSink {
+    /// Identifiant du sink
+    node_id: String,
+
+    /// Channel pour recevoir les chunks audio
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+
+    /// Configuration
+    config: ChromecastConfig,
+
+    /// État de la connexion (mock)
+    connected: bool,
+}
+
+impl ChromecastSink {
+    /// Crée un nouveau ChromecastSink
+    ///
+    /// # Arguments
+    ///
+    /// * `node_id` - Identifiant unique du sink
+    /// * `config` - Configuration du Chromecast
+    /// * `channel_size` - Taille du buffer du channel
+    pub fn new(
+        node_id: String,
+        config: ChromecastConfig,
+        channel_size: usize,
+    ) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let sink = Self {
+            node_id,
+            rx,
+            config,
+            connected: false,
+        };
+
+        (sink, tx)
+    }
+
+    /// Établit la connexion avec le Chromecast (mock)
+    async fn connect(&mut self) -> Result<(), AudioError> {
+        println!(
+            "[{}] Connecting to Chromecast '{}' at {}:{}...",
+            self.node_id, self.config.device_name, self.config.device_address, self.config.port
+        );
+
+        // Simuler une connexion
+        tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+
+        self.connected = true;
+
+        println!(
+            "[{}] Connected to Chromecast '{}' successfully",
+            self.node_id, self.config.device_name
+        );
+
+        Ok(())
+    }
+
+    /// Envoie un chunk au Chromecast (mock)
+    async fn send_chunk(&self, _chunk: &AudioChunk) -> Result<(), AudioError> {
+        if !self.connected {
+            return Err(AudioError::ProcessingError(
+                "Not connected to Chromecast".to_string(),
+            ));
+        }
+
+        // Dans une vraie implémentation:
+        // 1. Appliquer le gain
+        // 2. Encoder dans le format approprié (MP3, AAC, etc.)
+        // 3. Envoyer via le protocole Chromecast
+
+        // Pour l'instant, simplement simuler un délai d'envoi
+        tokio::time::sleep(tokio::time::Duration::from_micros(50)).await;
+
+        Ok(())
+    }
+
+    /// Déconnecte proprement du Chromecast (mock)
+    async fn disconnect(&mut self) -> Result<(), AudioError> {
+        if self.connected {
+            println!(
+                "[{}] Disconnecting from Chromecast '{}'...",
+                self.node_id, self.config.device_name
+            );
+
+            // Simuler la déconnexion
+            tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+
+            self.connected = false;
+
+            println!("[{}] Disconnected successfully", self.node_id);
+        }
+
+        Ok(())
+    }
+
+    /// Démarre la boucle de traitement du ChromecastSink
+    pub async fn run(mut self) -> Result<ChromecastStats, AudioError> {
+        // Établir la connexion
+        self.connect().await?;
+
+        let mut stats = ChromecastStats::new(self.node_id.clone(), self.config.device_name.clone());
+
+        // Boucle principale
+        while let Some(chunk) = self.rx.recv().await {
+            // Appliquer le gain si nécessaire
+            let chunk_to_send = if chunk.gain_db().abs() > f64::EPSILON {
+                Arc::clone(&chunk).apply_gain()
+            } else {
+                Arc::clone(&chunk)
+            };
+
+            // Envoyer au Chromecast
+            self.send_chunk(&chunk_to_send).await?;
+
+            stats.record_chunk(&chunk_to_send);
+        }
+
+        // Déconnexion propre
+        self.disconnect().await?;
+
+        stats.finalize();
+        Ok(stats)
+    }
+}
+
+/// Statistiques du ChromecastSink
+#[derive(Debug, Clone)]
+pub struct ChromecastStats {
+    pub node_id: String,
+    pub device_name: String,
+    pub chunks_sent: u64,
+    pub total_samples: u64,
+    pub total_duration_sec: f64,
+}
+
+impl ChromecastStats {
+    pub fn new(node_id: String, device_name: String) -> Self {
+        Self {
+            node_id,
+            device_name,
+            chunks_sent: 0,
+            total_samples: 0,
+            total_duration_sec: 0.0,
+        }
+    }
+
+    pub fn record_chunk(&mut self, chunk: &AudioChunk) {
+        self.chunks_sent += 1;
+        self.total_samples += chunk.len() as u64;
+        self.total_duration_sec += chunk.len() as f64 / chunk.sample_rate() as f64;
+    }
+
+    pub fn finalize(&mut self) {
+        // Calculs finaux si nécessaire
+    }
+
+    pub fn display(&self) {
+        println!("\n=== Chromecast Statistics: {} ===", self.node_id);
+        println!("Device: {}", self.device_name);
+        println!("Chunks sent: {}", self.chunks_sent);
+        println!("Total samples: {}", self.total_samples);
+        println!("Total duration: {:.3} sec", self.total_duration_sec);
+        println!("==================================\n");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::i32;
+
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_chromecast_sink_basic() {
+        let config = ChromecastConfig {
+            device_address: "127.0.0.1".to_string(),
+            device_name: "Test Device".to_string(),
+            ..Default::default()
+        };
+
+        let (sink, tx) = ChromecastSink::new("test".to_string(), config, 10);
+
+        let handle = tokio::spawn(async move { sink.run().await });
+
+        // Envoyer quelques chunks
+        for i in 0..5 {
+            let stereo = vec![[i32::MAX / 2; 2]; 1000];
+            let chunk = AudioChunk::new(i, stereo, 48000, BitDepth::B24);
+            tx.send(chunk).await.unwrap();
+        }
+
+        drop(tx);
+
+        let stats = handle.await.unwrap().unwrap();
+        assert_eq!(stats.chunks_sent, 5);
+        assert_eq!(stats.device_name, "Test Device");
+    }
+}

old_code/pmoaudio/nodes/decoder_node.rs

@@ -0,0 +1,162 @@
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// DecoderNode - Décode des chunks audio
+///
+/// Version mock qui passe simplement les chunks (ou simule un décodage simple)
+pub struct DecoderNode {
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+    subscribers: MultiSubscriberNode,
+}
+
+impl DecoderNode {
+    pub fn new(channel_size: usize) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let node = Self {
+            rx,
+            subscribers: MultiSubscriberNode::new(),
+        };
+
+        (node, tx)
+    }
+
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.subscribers.add_subscriber(tx);
+    }
+
+    /// Mode passthrough - passe les chunks sans modification
+    pub async fn run_passthrough(mut self) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            self.subscribers.push(chunk).await?;
+        }
+        Ok(())
+    }
+
+    /// Mode mock décodage - simule un changement de sample rate
+    pub async fn run_with_resampling(mut self, target_sample_rate: u32) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            if chunk.sample_rate() == target_sample_rate {
+                // Pas besoin de resampling
+                self.subscribers.push(chunk).await?;
+            } else {
+                // Simuler un resampling (mock simple)
+                let ratio = target_sample_rate as f64 / chunk.sample_rate() as f64;
+                let new_len = (chunk.len() as f64 * ratio) as usize;
+
+                let pairs = chunk.to_pairs_f32();
+                let mut resampled = Vec::with_capacity(new_len);
+
+                // Resampling linéaire simple (mock)
+                for i in 0..new_len {
+                    let src_pos = i as f64 / ratio;
+                    let src_idx = src_pos as usize;
+
+                    if src_idx + 1 < pairs.len() {
+                        let frac = src_pos - src_idx as f64;
+                        let alpha = (1.0 - frac) as f32;
+                        let beta = frac as f32;
+                        let left_sample = pairs[src_idx][0] * alpha + pairs[src_idx + 1][0] * beta;
+                        let right_sample = pairs[src_idx][1] * alpha + pairs[src_idx + 1][1] * beta;
+
+                        resampled.push([left_sample, right_sample]);
+                    } else if src_idx < pairs.len() {
+                        resampled.push(pairs[src_idx]);
+                    }
+                }
+
+                let mut new_chunk = AudioChunk::from_pairs_f32(
+                    chunk.order(),
+                    resampled,
+                    target_sample_rate,
+                    chunk.bit_depth(),
+                );
+                if chunk.gain_db().abs() > f64::EPSILON {
+                    new_chunk = new_chunk.set_gain_db(chunk.gain_db());
+                }
+                self.subscribers.push(new_chunk).await?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_decoder_passthrough() {
+        let (mut node, tx) = DecoderNode::new(10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run_passthrough().await.unwrap();
+        });
+
+        // Envoyer un chunk
+        let chunk = AudioChunk::from_channels_f32(
+            0,
+            vec![1.0, 2.0, 3.0],
+            vec![4.0, 5.0, 6.0],
+            48000,
+            BitDepth::B24,
+        );
+        tx.send(chunk.clone()).await.unwrap();
+
+        // Recevoir le chunk
+        let received = out_rx.recv().await.unwrap();
+        assert!(Arc::ptr_eq(&chunk, &received));
+    }
+
+    #[tokio::test]
+    async fn test_decoder_resampling() {
+        let (mut node, tx) = DecoderNode::new(10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run_with_resampling(96000).await.unwrap();
+        });
+
+        // Envoyer un chunk à 48000 Hz
+        let chunk =
+            AudioChunk::from_channels_f32(0, vec![1.0; 100], vec![1.0; 100], 48000, BitDepth::B24);
+        tx.send(chunk).await.unwrap();
+
+        // Recevoir le chunk resampleé
+        let received = out_rx.recv().await.unwrap();
+        assert_eq!(received.sample_rate(), 96000);
+        // Le chunk devrait être environ 2x plus grand
+        assert!(received.len() > 150 && received.len() < 250);
+    }
+
+    #[tokio::test]
+    async fn test_decoder_no_resampling_needed() {
+        let (mut node, tx) = DecoderNode::new(10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run_with_resampling(48000).await.unwrap();
+        });
+
+        // Envoyer un chunk déjà au bon sample rate
+        let chunk =
+            AudioChunk::from_channels_f32(0, vec![1.0; 100], vec![1.0; 100], 48000, BitDepth::B24);
+        tx.send(chunk.clone()).await.unwrap();
+
+        // Le chunk devrait être passé sans modification
+        let received = out_rx.recv().await.unwrap();
+        assert!(Arc::ptr_eq(&chunk, &received));
+    }
+}

old_code/pmoaudio/nodes/disk_sink.rs

@@ -0,0 +1,500 @@
+//! DiskSink - Écrit le flux audio dans un fichier
+//!
+//! Ce module fournit un sink qui écrit les chunks audio sur disque,
+//! avec support de la dérivation automatique du nom de fichier depuis la source.
+
+use crate::{events::SourceNameUpdateEvent, nodes::AudioError, AudioChunk};
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::fs::File;
+use tokio::io::AsyncWriteExt;
+use tokio::sync::{mpsc, RwLock};
+
+/// Configuration pour le DiskSink
+#[derive(Debug, Clone)]
+pub struct DiskSinkConfig {
+    /// Chemin racine où écrire les fichiers
+    pub output_dir: PathBuf,
+
+    /// Nom de fichier explicite (optionnel)
+    /// Si None, sera dérivé du nom de la source
+    pub filename: Option<String>,
+
+    /// Format d'écriture
+    pub format: AudioFileFormat,
+
+    /// Taille du buffer d'écriture (en chunks)
+    pub buffer_size: usize,
+}
+
+impl Default for DiskSinkConfig {
+    fn default() -> Self {
+        Self {
+            output_dir: PathBuf::from("."),
+            filename: None,
+            format: AudioFileFormat::Wav,
+            buffer_size: 100,
+        }
+    }
+}
+
+/// Formats de fichiers audio supportés
+#[derive(Debug, Clone, Copy)]
+pub enum AudioFileFormat {
+    /// Format WAV (non compressé)
+    Wav,
+    /// Format FLAC (compressé sans perte)
+    Flac,
+    /// Format brut PCM
+    Raw,
+}
+
+impl AudioFileFormat {
+    /// Retourne l'extension de fichier appropriée
+    pub fn extension(&self) -> &str {
+        match self {
+            AudioFileFormat::Wav => "wav",
+            AudioFileFormat::Flac => "flac",
+            AudioFileFormat::Raw => "pcm",
+        }
+    }
+}
+
+/// DiskSink - Écrit le flux audio dans un fichier sur disque
+///
+/// Ce sink consomme les chunks audio et les écrit dans un fichier.
+/// Le nom du fichier peut être dérivé automatiquement du nom de la source
+/// via les événements `SourceNameUpdateEvent`.
+///
+/// # Caractéristiques
+///
+/// - Écriture asynchrone avec buffer
+/// - Dérivation automatique du nom de fichier depuis la source
+/// - Support de plusieurs formats (WAV, FLAC, PCM brut)
+/// - Gestion du gain : applique le gain avant l'écriture
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::{DiskSink, DiskSinkConfig};
+/// use std::path::PathBuf;
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let config = DiskSinkConfig {
+///         output_dir: PathBuf::from("/tmp/audio"),
+///         filename: Some("output.wav".to_string()),
+///         ..Default::default()
+///     };
+///
+///     let (sink, sink_tx) = DiskSink::new("disk1".to_string(), config, 10);
+///
+///     tokio::spawn(async move {
+///         sink.run().await.unwrap()
+///     });
+/// }
+/// ```
+pub struct DiskSink {
+    /// Identifiant du sink
+    node_id: String,
+
+    /// Channel pour recevoir les chunks audio
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+
+    /// Configuration
+    config: DiskSinkConfig,
+
+    /// Nom de fichier résolu (partagé)
+    resolved_filename: Arc<RwLock<Option<PathBuf>>>,
+
+    /// Receiver pour les événements de nom de source (optionnel)
+    source_name_rx: Option<mpsc::Receiver<SourceNameUpdateEvent>>,
+
+    /// Writer pour le fichier
+    writer: Option<AudioFileWriter>,
+}
+
+impl DiskSink {
+    /// Crée un nouveau DiskSink
+    ///
+    /// # Arguments
+    ///
+    /// * `node_id` - Identifiant unique du sink
+    /// * `config` - Configuration du sink
+    /// * `channel_size` - Taille du buffer du channel
+    pub fn new(
+        node_id: String,
+        config: DiskSinkConfig,
+        channel_size: usize,
+    ) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let sink = Self {
+            node_id,
+            rx,
+            config,
+            resolved_filename: Arc::new(RwLock::new(None)),
+            source_name_rx: None,
+            writer: None,
+        };
+
+        (sink, tx)
+    }
+
+    /// Configure la source des événements de nom de source
+    pub fn set_source_name_source(&mut self, rx: mpsc::Receiver<SourceNameUpdateEvent>) {
+        self.source_name_rx = Some(rx);
+    }
+
+    /// Résout le nom du fichier de sortie
+    ///
+    /// Si un filename explicite est fourni dans la config, l'utilise.
+    /// Sinon, utilise le source_name avec l'extension appropriée.
+    fn resolve_filename(&self, source_name: Option<&str>) -> PathBuf {
+        let filename = if let Some(ref explicit_name) = self.config.filename {
+            explicit_name.clone()
+        } else if let Some(name) = source_name {
+            // Nettoyer le nom de la source pour en faire un nom de fichier valide
+            let clean_name = name
+                .chars()
+                .map(|c| {
+                    if c.is_alphanumeric() || c == '_' || c == '-' {
+                        c
+                    } else {
+                        '_'
+                    }
+                })
+                .collect::<String>();
+
+            format!("{}.{}", clean_name, self.config.format.extension())
+        } else {
+            // Fallback sur un nom par défaut
+            format!("{}.{}", self.node_id, self.config.format.extension())
+        };
+
+        self.config.output_dir.join(filename)
+    }
+
+    /// Initialise le writer pour le fichier de sortie
+    async fn initialize_writer(&mut self, source_name: Option<&str>) -> Result<(), AudioError> {
+        let path = self.resolve_filename(source_name);
+        *self.resolved_filename.write().await = Some(path.clone());
+
+        // Créer le répertoire parent si nécessaire
+        if let Some(parent) = path.parent() {
+            tokio::fs::create_dir_all(parent).await.map_err(|e| {
+                AudioError::ProcessingError(format!("Failed to create directory: {}", e))
+            })?;
+        }
+
+        // Créer le writer approprié selon le format
+        let writer = match self.config.format {
+            AudioFileFormat::Wav => AudioFileWriter::new_wav(path).await?,
+            AudioFileFormat::Flac => {
+                // FLAC nécessiterait une bibliothèque externe, pour l'instant utiliser WAV
+                AudioFileWriter::new_wav(path).await?
+            }
+            AudioFileFormat::Raw => AudioFileWriter::new_raw(path).await?,
+        };
+
+        self.writer = Some(writer);
+        Ok(())
+    }
+
+    /// Démarre la boucle de traitement du DiskSink
+    pub async fn run(mut self) -> Result<DiskSinkStats, AudioError> {
+        let mut stats = DiskSinkStats::new(self.node_id.clone());
+        let mut source_name: Option<String> = None;
+        let mut initialized = false;
+
+        loop {
+            tokio::select! {
+                // Recevoir les chunks audio
+                chunk_opt = self.rx.recv() => {
+                    match chunk_opt {
+                        Some(chunk) => {
+                            // Initialiser le writer à la réception du premier chunk
+                            if !initialized {
+                                self.initialize_writer(source_name.as_deref()).await?;
+                                initialized = true;
+                            }
+
+                            // Appliquer le gain avant l'écriture
+                            let chunk_with_gain = if chunk.gain_db().abs() > f64::EPSILON {
+                                Arc::clone(&chunk).apply_gain()
+                            } else {
+                                Arc::clone(&chunk)
+                            };
+
+                            // Écrire le chunk
+                            if let Some(ref mut writer) = self.writer {
+                                writer.write_chunk(&chunk_with_gain).await?;
+                                stats.record_chunk(&chunk_with_gain);
+                            }
+                        }
+                        None => {
+                            // Channel fermé, terminer
+                            break;
+                        }
+                    }
+                }
+
+                // Recevoir les mises à jour du nom de source
+                source_event_opt = async {
+                    if let Some(ref mut rx) = self.source_name_rx {
+                        rx.recv().await
+                    } else {
+                        std::future::pending().await
+                    }
+                } => {
+                    if let Some(event) = source_event_opt {
+                        source_name = Some(event.source_name.clone());
+
+                        // Si on n'a pas encore initialisé, le nom sera utilisé plus tard
+                        // Sinon, on pourrait décider de fermer le fichier actuel et d'en créer un nouveau
+                    }
+                }
+            }
+        }
+
+        // Fermer le fichier proprement
+        if let Some(writer) = self.writer {
+            writer.close().await?;
+        }
+
+        stats.finalize();
+        Ok(stats)
+    }
+}
+
+/// Writer pour fichiers audio
+struct AudioFileWriter {
+    file: File,
+    format: AudioFileFormat,
+    sample_rate: Option<u32>,
+    total_samples: usize,
+}
+
+impl AudioFileWriter {
+    /// Crée un writer WAV
+    async fn new_wav(path: PathBuf) -> Result<Self, AudioError> {
+        let file = File::create(path)
+            .await
+            .map_err(|e| AudioError::ProcessingError(format!("Failed to create file: {}", e)))?;
+
+        Ok(Self {
+            file,
+            format: AudioFileFormat::Wav,
+            sample_rate: None,
+            total_samples: 0,
+        })
+    }
+
+    /// Crée un writer pour PCM brut
+    async fn new_raw(path: PathBuf) -> Result<Self, AudioError> {
+        let file = File::create(path)
+            .await
+            .map_err(|e| AudioError::ProcessingError(format!("Failed to create file: {}", e)))?;
+
+        Ok(Self {
+            file,
+            format: AudioFileFormat::Raw,
+            sample_rate: None,
+            total_samples: 0,
+        })
+    }
+
+    /// Écrit un chunk audio
+    async fn write_chunk(&mut self, chunk: &AudioChunk) -> Result<(), AudioError> {
+        // Enregistrer le sample rate du premier chunk
+        if self.sample_rate.is_none() {
+            let sr = chunk.sample_rate();
+            self.sample_rate = Some(sr);
+
+            // Pour WAV, écrire l'en-tête (simplifié)
+            if matches!(self.format, AudioFileFormat::Wav) {
+                self.write_wav_header(sr).await?;
+            }
+        }
+
+        // Convertir en bytes (little-endian 16-bit PCM)
+        let mut bytes = Vec::with_capacity(chunk.len() * 4);
+        let max_val = chunk.bit_depth().max_value();
+        for frame in chunk.frames() {
+            let left = (frame[0] as f32 / max_val).clamp(-1.0, 1.0);
+            let right = (frame[1] as f32 / max_val).clamp(-1.0, 1.0);
+            let sample_i16 = (left * 32767.0) as i16;
+            bytes.extend_from_slice(&sample_i16.to_le_bytes());
+            let sample_r16 = (right * 32767.0) as i16;
+            bytes.extend_from_slice(&sample_r16.to_le_bytes());
+        }
+
+        self.file.write_all(&bytes).await.map_err(|e| {
+            AudioError::ProcessingError(format!("Failed to write audio data: {}", e))
+        })?;
+
+        self.total_samples += chunk.len();
+        Ok(())
+    }
+
+    /// Écrit un en-tête WAV simplifié
+    async fn write_wav_header(&mut self, sample_rate: u32) -> Result<(), AudioError> {
+        // En-tête WAV basique (sera mis à jour à la fermeture)
+        let mut header = Vec::new();
+
+        // RIFF chunk
+        header.extend_from_slice(b"RIFF");
+        header.extend_from_slice(&0u32.to_le_bytes()); // Taille (à mettre à jour)
+        header.extend_from_slice(b"WAVE");
+
+        // fmt chunk
+        header.extend_from_slice(b"fmt ");
+        header.extend_from_slice(&16u32.to_le_bytes()); // Taille du fmt chunk
+        header.extend_from_slice(&1u16.to_le_bytes()); // Format PCM
+        header.extend_from_slice(&2u16.to_le_bytes()); // 2 canaux (stéréo)
+        header.extend_from_slice(&sample_rate.to_le_bytes());
+        header.extend_from_slice(&(sample_rate * 4).to_le_bytes()); // Byte rate
+        header.extend_from_slice(&4u16.to_le_bytes()); // Block align
+        header.extend_from_slice(&16u16.to_le_bytes()); // Bits per sample
+
+        // data chunk header
+        header.extend_from_slice(b"data");
+        header.extend_from_slice(&0u32.to_le_bytes()); // Taille des données (à mettre à jour)
+
+        self.file.write_all(&header).await.map_err(|e| {
+            AudioError::ProcessingError(format!("Failed to write WAV header: {}", e))
+        })?;
+
+        Ok(())
+    }
+
+    /// Ferme le fichier et met à jour l'en-tête si nécessaire
+    async fn close(mut self) -> Result<(), AudioError> {
+        if matches!(self.format, AudioFileFormat::Wav) {
+            // Mettre à jour les tailles dans l'en-tête WAV
+            let data_size = (self.total_samples * 4) as u32; // 2 bytes per sample * 2 channels
+            let file_size = data_size + 36;
+
+            // Positionner au début et réécrire les tailles
+            use tokio::io::AsyncSeekExt;
+            self.file
+                .seek(std::io::SeekFrom::Start(4))
+                .await
+                .map_err(|e| {
+                    AudioError::ProcessingError(format!("Failed to seek in file: {}", e))
+                })?;
+            self.file
+                .write_all(&file_size.to_le_bytes())
+                .await
+                .map_err(|e| {
+                    AudioError::ProcessingError(format!("Failed to update file size: {}", e))
+                })?;
+
+            self.file
+                .seek(std::io::SeekFrom::Start(40))
+                .await
+                .map_err(|e| {
+                    AudioError::ProcessingError(format!("Failed to seek in file: {}", e))
+                })?;
+            self.file
+                .write_all(&data_size.to_le_bytes())
+                .await
+                .map_err(|e| {
+                    AudioError::ProcessingError(format!("Failed to update data size: {}", e))
+                })?;
+        }
+
+        self.file
+            .flush()
+            .await
+            .map_err(|e| AudioError::ProcessingError(format!("Failed to flush file: {}", e)))?;
+
+        Ok(())
+    }
+}
+
+/// Statistiques du DiskSink
+#[derive(Debug, Clone)]
+pub struct DiskSinkStats {
+    pub node_id: String,
+    pub chunks_written: u64,
+    pub total_samples: u64,
+    pub total_duration_sec: f64,
+}
+
+impl DiskSinkStats {
+    pub fn new(node_id: String) -> Self {
+        Self {
+            node_id,
+            chunks_written: 0,
+            total_samples: 0,
+            total_duration_sec: 0.0,
+        }
+    }
+
+    pub fn record_chunk(&mut self, chunk: &AudioChunk) {
+        self.chunks_written += 1;
+        self.total_samples += chunk.len() as u64;
+        self.total_duration_sec += chunk.len() as f64 / chunk.sample_rate() as f64;
+    }
+
+    pub fn finalize(&mut self) {
+        // Pourrait effectuer des calculs finaux ici
+    }
+
+    pub fn display(&self) {
+        println!("\n=== DiskSink Statistics: {} ===", self.node_id);
+        println!("Chunks written: {}", self.chunks_written);
+        println!("Total samples: {}", self.total_samples);
+        println!("Total duration: {:.3} sec", self.total_duration_sec);
+        println!("============================\n");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_disk_sink_basic() {
+        let temp_dir = std::env::temp_dir().join("pmoaudio_test");
+        tokio::fs::create_dir_all(&temp_dir).await.unwrap();
+
+        let config = DiskSinkConfig {
+            output_dir: temp_dir.clone(),
+            filename: Some("test_output.wav".to_string()),
+            format: AudioFileFormat::Wav,
+            buffer_size: 10,
+        };
+
+        let (sink, tx) = DiskSink::new("test".to_string(), config, 10);
+
+        let handle = tokio::spawn(async move { sink.run().await });
+
+        // Envoyer quelques chunks
+        for i in 0..5 {
+            let chunk = AudioChunk::from_channels_f32(
+                i,
+                vec![0.5; 1000],
+                vec![0.5; 1000],
+                48000,
+                BitDepth::B24,
+            );
+            tx.send(chunk).await.unwrap();
+        }
+
+        drop(tx);
+
+        let stats = handle.await.unwrap().unwrap();
+        assert_eq!(stats.chunks_written, 5);
+
+        // Vérifier que le fichier existe
+        let output_path = temp_dir.join("test_output.wav");
+        assert!(output_path.exists());
+
+        // Nettoyage
+        tokio::fs::remove_file(output_path).await.ok();
+        tokio::fs::remove_dir(temp_dir).await.ok();
+    }
+}

old_code/pmoaudio/nodes/dsp_node.rs

@@ -0,0 +1,254 @@
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// DspNode - Applique des transformations DSP aux chunks audio
+///
+/// Clone les données uniquement si elles doivent être modifiées
+pub struct DspNode {
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+    subscribers: MultiSubscriberNode,
+    gain_db: f32,
+}
+
+impl DspNode {
+    pub fn new(channel_size: usize, gain_db: f32) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let node = Self {
+            rx,
+            subscribers: MultiSubscriberNode::new(),
+            gain_db,
+        };
+
+        (node, tx)
+    }
+
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.subscribers.add_subscriber(tx);
+    }
+
+    /// Applique le gain aux chunks
+    pub async fn run(mut self) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            if self.gain_db.abs() < f32::EPSILON {
+                // Gain = 0 dB, pas de transformation nécessaire
+                self.subscribers.push(chunk).await?;
+                continue;
+            }
+
+            let gain_linear = AudioChunk::gain_linear_from_db(self.gain_db as f64) as f32;
+            let mut pairs = chunk.to_pairs_f32();
+            for frame in &mut pairs {
+                frame[0] *= gain_linear;
+                frame[1] *= gain_linear;
+            }
+
+            let mut new_chunk = AudioChunk::from_pairs_f32(
+                chunk.order(),
+                pairs,
+                chunk.sample_rate(),
+                chunk.bit_depth(),
+            );
+            if chunk.gain_db().abs() > f64::EPSILON {
+                new_chunk = new_chunk.set_gain_db(chunk.gain_db());
+            }
+            self.subscribers.push(new_chunk).await?;
+        }
+        Ok(())
+    }
+
+    /// Met à jour le gain dynamiquement (nécessite un `Arc<RwLock<f32>>` dans une version réelle)
+    pub fn set_gain_db(&mut self, gain_db: f32) {
+        self.gain_db = gain_db;
+    }
+}
+
+/// DspNode avec filtre passe-bas simple (mock)
+#[allow(dead_code)]
+pub struct LowPassDspNode {
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+    subscribers: MultiSubscriberNode,
+    alpha: f32, // Coefficient du filtre
+    prev_left: f32,
+    prev_right: f32,
+}
+
+impl LowPassDspNode {
+    #[allow(dead_code)]
+    pub fn new(channel_size: usize, cutoff_ratio: f32) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        // Filtre RC simple: alpha = dt / (RC + dt)
+        // cutoff_ratio entre 0 (tout couper) et 1 (tout passer)
+        let alpha = cutoff_ratio.clamp(0.0, 1.0);
+
+        let node = Self {
+            rx,
+            subscribers: MultiSubscriberNode::new(),
+            alpha,
+            prev_left: 0.0,
+            prev_right: 0.0,
+        };
+
+        (node, tx)
+    }
+
+    #[allow(dead_code)]
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.subscribers.add_subscriber(tx);
+    }
+
+    #[allow(dead_code)]
+    pub async fn run(mut self) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            let pairs = chunk.to_pairs_f32();
+            let mut filtered = Vec::with_capacity(pairs.len());
+
+            for sample in pairs.iter() {
+                self.prev_left = self.prev_left + self.alpha * (sample[0] - self.prev_left);
+                self.prev_right = self.prev_right + self.alpha * (sample[1] - self.prev_right);
+                filtered.push([self.prev_left, self.prev_right]);
+            }
+
+            let mut new_chunk = AudioChunk::from_pairs_f32(
+                chunk.order(),
+                filtered,
+                chunk.sample_rate(),
+                chunk.bit_depth(),
+            );
+            if chunk.gain_db().abs() > f64::EPSILON {
+                new_chunk = new_chunk.set_gain_db(chunk.gain_db());
+            }
+
+            self.subscribers.push(new_chunk).await?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_dsp_node_unity_gain() {
+        let (mut node, tx) = DspNode::new(10, 0.0);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer un chunk
+        let chunk = AudioChunk::from_channels_f32(
+            0,
+            vec![0.25, 0.5, 0.75],
+            vec![0.1, 0.2, 0.3],
+            48000,
+            BitDepth::B24,
+        );
+        tx.send(chunk.clone()).await.unwrap();
+
+        // Avec gain = 1.0, le chunk ne devrait pas être cloné
+        let received = out_rx.recv().await.unwrap();
+        assert!(Arc::ptr_eq(&chunk, &received));
+    }
+
+    #[tokio::test]
+    async fn test_dsp_node_gain() {
+        let gain_db = AudioChunk::gain_db_from_linear(2.0) as f32;
+        let (mut node, tx) = DspNode::new(10, gain_db);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer un chunk
+        let chunk = AudioChunk::from_channels_f32(
+            0,
+            vec![0.25, 0.5, 0.75],
+            vec![0.1, 0.2, 0.3],
+            48000,
+            BitDepth::B24,
+        );
+        tx.send(chunk).await.unwrap();
+
+        // Vérifier que le gain a été appliqué
+        let received = out_rx.recv().await.unwrap();
+        let frames = received.to_pairs_f32();
+        const EPS: f32 = 1e-3;
+        assert!((frames[0][0] - 0.5).abs() < EPS);
+        assert!((frames[1][0] - 1.0).abs() < EPS);
+        assert!((frames[2][0] - 1.0).abs() < EPS); // Clamp at full scale
+        assert!((frames[0][1] - 0.2).abs() < EPS);
+        assert!((frames[1][1] - 0.4).abs() < EPS);
+        assert!((frames[2][1] - 0.6).abs() < EPS);
+    }
+
+    #[tokio::test]
+    async fn test_lowpass_dsp_node() {
+        let (mut node, tx) = LowPassDspNode::new(10, 0.5);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer un chunk avec un signal carré
+        let chunk = AudioChunk::from_channels_f32(
+            0,
+            vec![1.0, 1.0, 1.0, -1.0, -1.0, -1.0],
+            vec![1.0, 1.0, 1.0, -1.0, -1.0, -1.0],
+            48000,
+            BitDepth::B24,
+        );
+        tx.send(chunk).await.unwrap();
+
+        // Le filtre devrait lisser le signal
+        let received = out_rx.recv().await.unwrap();
+        let frames = received.to_pairs_f32();
+        assert!(frames[0][0].abs() < 1.0); // Premier échantillon lissé
+        assert!(frames[2][0].abs() < 1.0); // Signal ne devrait pas atteindre 1.0 immédiatement
+    }
+
+    #[tokio::test]
+    async fn test_dsp_node_multiple_subscribers() {
+        let gain_db = AudioChunk::gain_db_from_linear(0.5) as f32;
+        let (mut node, tx) = DspNode::new(10, gain_db);
+        let (out_tx1, mut out_rx1) = mpsc::channel(10);
+        let (out_tx2, mut out_rx2) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx1);
+        node.add_subscriber(out_tx2);
+
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        let chunk =
+            AudioChunk::from_channels_f32(0, vec![0.8, 0.4], vec![0.8, 0.4], 48000, BitDepth::B24);
+        tx.send(chunk).await.unwrap();
+
+        // Les deux abonnés devraient recevoir le même Arc
+        let received1 = out_rx1.recv().await.unwrap();
+        let received2 = out_rx2.recv().await.unwrap();
+
+        assert!(Arc::ptr_eq(&received1, &received2));
+        let frames = received1.to_pairs_f32();
+        const EPS: f32 = 1e-3;
+        assert!((frames[0][0] - 0.4).abs() < EPS); // 0.8 * 0.5
+        assert!((frames[1][0] - 0.2).abs() < EPS); // 0.4 * 0.5
+    }
+}

old_code/pmoaudio/nodes/mpd_sink.rs

@@ -0,0 +1,398 @@
+//! MpdSink - Envoie le flux audio à un démon MPD (Music Player Daemon)
+//!
+//! Ce module fournit un sink qui streame l'audio vers un démon MPD distant ou local.
+//! Note: Cette implémentation est une version mock/skeleton. Une vraie implémentation
+//! nécessiterait le protocole MPD complet et l'utilisation de bibliothèques comme `mpd`.
+
+use crate::{nodes::AudioError, AudioChunk};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// Configuration pour le MpdSink
+#[derive(Debug, Clone)]
+pub struct MpdConfig {
+    /// Adresse du serveur MPD
+    pub host: String,
+
+    /// Port du serveur MPD (défaut: 6600)
+    pub port: u16,
+
+    /// Mot de passe optionnel
+    pub password: Option<String>,
+
+    /// Nom de l'output MPD à utiliser (optionnel)
+    pub output_name: Option<String>,
+
+    /// Taille du buffer
+    pub buffer_size: usize,
+
+    /// Format d'envoi
+    pub format: MpdAudioFormat,
+}
+
+impl Default for MpdConfig {
+    fn default() -> Self {
+        Self {
+            host: "localhost".to_string(),
+            port: 6600,
+            password: None,
+            output_name: None,
+            buffer_size: 50,
+            format: MpdAudioFormat::S16Le,
+        }
+    }
+}
+
+/// Formats audio supportés par MPD
+#[derive(Debug, Clone, Copy)]
+pub enum MpdAudioFormat {
+    /// Signed 16-bit Little Endian
+    S16Le,
+    /// Signed 24-bit Little Endian
+    S24Le,
+    /// Signed 32-bit Little Endian
+    S32Le,
+    /// Float 32-bit
+    F32,
+}
+
+impl MpdAudioFormat {
+    /// Retourne le nom du format pour le protocole MPD
+    pub fn as_mpd_string(&self) -> &str {
+        match self {
+            MpdAudioFormat::S16Le => "16:16:2",
+            MpdAudioFormat::S24Le => "24:24:2",
+            MpdAudioFormat::S32Le => "32:32:2",
+            MpdAudioFormat::F32 => "f:32:2",
+        }
+    }
+}
+
+/// MpdSink - Streame vers un démon MPD
+///
+/// Ce sink se connecte à un serveur MPD et lui envoie le flux audio.
+/// MPD peut ensuite router l'audio vers différents outputs (ALSA, PulseAudio, HTTP, etc.).
+///
+/// # Implémentation actuelle
+///
+/// Cette version est un mock qui simule la communication avec MPD.
+/// Pour une vraie implémentation, il faudrait:
+/// - Implémenter le protocole MPD (commandes textuelles sur TCP)
+/// - S'authentifier si nécessaire
+/// - Configurer le format audio
+/// - Envoyer les données PCM via le protocole approprié
+/// - Gérer les commandes de contrôle (play, pause, stop)
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::{MpdSink, MpdConfig};
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let config = MpdConfig {
+///         host: "localhost".to_string(),
+///         port: 6600,
+///         password: None,
+///         ..Default::default()
+///     };
+///
+///     let (sink, sink_tx) = MpdSink::new("mpd1".to_string(), config, 10);
+///
+///     tokio::spawn(async move {
+///         sink.run().await.unwrap()
+///     });
+/// }
+/// ```
+pub struct MpdSink {
+    /// Identifiant du sink
+    node_id: String,
+
+    /// Channel pour recevoir les chunks audio
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+
+    /// Configuration
+    config: MpdConfig,
+
+    /// État de la connexion (mock)
+    connected: bool,
+
+    /// Version du serveur MPD (mock)
+    mpd_version: Option<String>,
+}
+
+impl MpdSink {
+    /// Crée un nouveau MpdSink
+    ///
+    /// # Arguments
+    ///
+    /// * `node_id` - Identifiant unique du sink
+    /// * `config` - Configuration MPD
+    /// * `channel_size` - Taille du buffer du channel
+    pub fn new(
+        node_id: String,
+        config: MpdConfig,
+        channel_size: usize,
+    ) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let sink = Self {
+            node_id,
+            rx,
+            config,
+            connected: false,
+            mpd_version: None,
+        };
+
+        (sink, tx)
+    }
+
+    /// Établit la connexion avec le serveur MPD (mock)
+    async fn connect(&mut self) -> Result<(), AudioError> {
+        println!(
+            "[{}] Connecting to MPD at {}:{}...",
+            self.node_id, self.config.host, self.config.port
+        );
+
+        // Simuler une connexion TCP
+        tokio::time::sleep(tokio::time::Duration::from_millis(300)).await;
+
+        // Dans une vraie implémentation:
+        // 1. Établir connexion TCP
+        // 2. Lire la bannière de version
+        // 3. S'authentifier si password fourni
+        // 4. Configurer le format audio
+
+        self.mpd_version = Some("0.23.0".to_string());
+        self.connected = true;
+
+        println!(
+            "[{}] Connected to MPD v{} successfully",
+            self.node_id,
+            self.mpd_version.as_ref().unwrap()
+        );
+
+        // Configurer le format audio
+        self.configure_audio_format().await?;
+
+        Ok(())
+    }
+
+    /// Configure le format audio sur MPD (mock)
+    async fn configure_audio_format(&self) -> Result<(), AudioError> {
+        println!(
+            "[{}] Configuring audio format: {}",
+            self.node_id,
+            self.config.format.as_mpd_string()
+        );
+
+        // Dans une vraie implémentation:
+        // Envoyer une commande MPD pour configurer le format
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        Ok(())
+    }
+
+    /// Envoie un chunk au serveur MPD (mock)
+    async fn send_chunk(&self, _chunk: &AudioChunk) -> Result<(), AudioError> {
+        if !self.connected {
+            return Err(AudioError::ProcessingError(
+                "Not connected to MPD".to_string(),
+            ));
+        }
+
+        // Dans une vraie implémentation:
+        // 1. Appliquer le gain
+        // 2. Convertir dans le format approprié (S16LE, etc.)
+        // 3. Envoyer via le protocole MPD (probablement via une commande `sendmessage` ou pipe)
+
+        // Simuler un délai d'envoi
+        tokio::time::sleep(tokio::time::Duration::from_micros(50)).await;
+
+        Ok(())
+    }
+
+    /// Déconnecte proprement du serveur MPD (mock)
+    async fn disconnect(&mut self) -> Result<(), AudioError> {
+        if self.connected {
+            println!("[{}] Disconnecting from MPD...", self.node_id);
+
+            // Dans une vraie implémentation:
+            // Envoyer la commande "close"
+            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+            self.connected = false;
+
+            println!("[{}] Disconnected successfully", self.node_id);
+        }
+
+        Ok(())
+    }
+
+    /// Démarre la boucle de traitement du MpdSink
+    pub async fn run(mut self) -> Result<MpdStats, AudioError> {
+        // Établir la connexion
+        self.connect().await?;
+
+        let mut stats = MpdStats::new(
+            self.node_id.clone(),
+            format!("{}:{}", self.config.host, self.config.port),
+        );
+
+        // Boucle principale
+        while let Some(chunk) = self.rx.recv().await {
+            // Appliquer le gain si nécessaire
+            let chunk_to_send = if chunk.gain_db().abs() > f64::EPSILON {
+                Arc::clone(&chunk).apply_gain()
+            } else {
+                Arc::clone(&chunk)
+            };
+
+            // Envoyer au serveur MPD
+            self.send_chunk(&chunk_to_send).await?;
+
+            stats.record_chunk(&chunk_to_send);
+        }
+
+        // Déconnexion propre
+        self.disconnect().await?;
+
+        stats.finalize();
+        Ok(stats)
+    }
+
+    /// Retourne un handle pour contrôler le sink (mock)
+    pub fn get_handle(&self) -> MpdHandle {
+        MpdHandle {
+            node_id: self.node_id.clone(),
+        }
+    }
+}
+
+/// Handle pour contrôler le MpdSink
+///
+/// Permet d'envoyer des commandes de contrôle au serveur MPD
+#[derive(Clone)]
+pub struct MpdHandle {
+    node_id: String,
+}
+
+impl MpdHandle {
+    /// Commande play (mock)
+    pub async fn play(&self) -> Result<(), AudioError> {
+        println!("[{}] MPD command: play", self.node_id);
+        Ok(())
+    }
+
+    /// Commande pause (mock)
+    pub async fn pause(&self) -> Result<(), AudioError> {
+        println!("[{}] MPD command: pause", self.node_id);
+        Ok(())
+    }
+
+    /// Commande stop (mock)
+    pub async fn stop(&self) -> Result<(), AudioError> {
+        println!("[{}] MPD command: stop", self.node_id);
+        Ok(())
+    }
+
+    /// Change le volume MPD (0-100) (mock)
+    pub async fn set_volume(&self, volume: u8) -> Result<(), AudioError> {
+        let clamped = volume.min(100);
+        println!("[{}] MPD command: setvol {}", self.node_id, clamped);
+        Ok(())
+    }
+}
+
+/// Statistiques du MpdSink
+#[derive(Debug, Clone)]
+pub struct MpdStats {
+    pub node_id: String,
+    pub server_address: String,
+    pub chunks_sent: u64,
+    pub total_samples: u64,
+    pub total_duration_sec: f64,
+}
+
+impl MpdStats {
+    pub fn new(node_id: String, server_address: String) -> Self {
+        Self {
+            node_id,
+            server_address,
+            chunks_sent: 0,
+            total_samples: 0,
+            total_duration_sec: 0.0,
+        }
+    }
+
+    pub fn record_chunk(&mut self, chunk: &AudioChunk) {
+        self.chunks_sent += 1;
+        self.total_samples += chunk.len() as u64;
+        self.total_duration_sec += chunk.len() as f64 / chunk.sample_rate() as f64;
+    }
+
+    pub fn finalize(&mut self) {
+        // Calculs finaux si nécessaire
+    }
+
+    pub fn display(&self) {
+        println!("\n=== MPD Sink Statistics: {} ===", self.node_id);
+        println!("Server: {}", self.server_address);
+        println!("Chunks sent: {}", self.chunks_sent);
+        println!("Total samples: {}", self.total_samples);
+        println!("Total duration: {:.3} sec", self.total_duration_sec);
+        println!("===============================\n");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_mpd_sink_basic() {
+        let config = MpdConfig {
+            host: "localhost".to_string(),
+            port: 6600,
+            ..Default::default()
+        };
+
+        let (sink, tx) = MpdSink::new("test".to_string(), config, 10);
+
+        let handle = tokio::spawn(async move { sink.run().await });
+
+        // Envoyer quelques chunks
+        for i in 0..5 {
+            let chunk = AudioChunk::from_channels_f32(
+                i,
+                vec![0.5; 1000],
+                vec![0.5; 1000],
+                48000,
+                BitDepth::B24,
+            );
+            tx.send(chunk).await.unwrap();
+        }
+
+        drop(tx);
+
+        let stats = handle.await.unwrap().unwrap();
+        assert_eq!(stats.chunks_sent, 5);
+        assert_eq!(stats.server_address, "localhost:6600");
+    }
+
+    #[tokio::test]
+    async fn test_mpd_handle() {
+        let config = MpdConfig::default();
+        let (sink, _tx) = MpdSink::new("test".to_string(), config, 10);
+
+        let handle = sink.get_handle();
+
+        // Tester les commandes (mock)
+        handle.play().await.unwrap();
+        handle.pause().await.unwrap();
+        handle.set_volume(75).await.unwrap();
+        handle.stop().await.unwrap();
+    }
+}

old_code/pmoaudio/nodes/sink_node.rs

@@ -0,0 +1,212 @@
+use crate::{nodes::AudioError, AudioChunk};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// SinkNode - Node terminal qui consomme les chunks audio
+///
+/// Version mock pour tests et logging
+pub struct SinkNode {
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+    name: String,
+}
+
+impl SinkNode {
+    pub fn new(name: String, channel_size: usize) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let node = Self { rx, name };
+
+        (node, tx)
+    }
+
+    /// Version silencieuse - consomme les chunks sans action
+    pub async fn run_silent(mut self) -> Result<(), AudioError> {
+        while let Some(_chunk) = self.rx.recv().await {
+            // Ne rien faire, juste consommer
+        }
+        Ok(())
+    }
+
+    /// Version avec logging
+    pub async fn run_with_logging(mut self) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            println!(
+                "[{}] Received chunk #{} - {} samples @ {} Hz",
+                self.name,
+                chunk.order(),
+                chunk.len(),
+                chunk.sample_rate()
+            );
+        }
+        Ok(())
+    }
+
+    /// Version avec statistiques
+    pub async fn run_with_stats(mut self) -> Result<SinkStats, AudioError> {
+        let mut stats = SinkStats::new(self.name.clone());
+
+        while let Some(chunk) = self.rx.recv().await {
+            stats.process_chunk(&chunk);
+        }
+
+        Ok(stats)
+    }
+
+    /// Version mock pour écriture dans un fichier (simule l'écriture)
+    pub async fn run_mock_file_writer(mut self) -> Result<usize, AudioError> {
+        let mut total_samples = 0;
+
+        while let Some(chunk) = self.rx.recv().await {
+            total_samples += chunk.len();
+            // Simuler l'écriture avec un petit délai
+            tokio::time::sleep(tokio::time::Duration::from_micros(10)).await;
+        }
+
+        Ok(total_samples)
+    }
+}
+
+/// Statistiques collectées par un SinkNode
+#[derive(Debug, Clone)]
+pub struct SinkStats {
+    pub name: String,
+    pub chunks_received: u64,
+    pub total_samples: u64,
+    pub total_duration_sec: f64,
+    pub peak_left: f32,
+    pub peak_right: f32,
+    pub rms_left: f64,
+    pub rms_right: f64,
+}
+
+impl SinkStats {
+    pub fn new(name: String) -> Self {
+        Self {
+            name,
+            chunks_received: 0,
+            total_samples: 0,
+            total_duration_sec: 0.0,
+            peak_left: 0.0,
+            peak_right: 0.0,
+            rms_left: 0.0,
+            rms_right: 0.0,
+        }
+    }
+
+    pub fn process_chunk(&mut self, chunk: &AudioChunk) {
+        self.chunks_received += 1;
+        let len = chunk.len() as u64;
+        self.total_samples += len;
+        self.total_duration_sec += chunk.len() as f64 / chunk.sample_rate() as f64;
+
+        let inv_max = 1.0f32 / chunk.bit_depth().max_value();
+        let mut peak_left = self.peak_left;
+        let mut peak_right = self.peak_right;
+        let mut sum_squares_left = 0.0f64;
+        let mut sum_squares_right = 0.0f64;
+
+        for frame in chunk.frames() {
+            let left = frame[0] as f32 * inv_max;
+            let right = frame[1] as f32 * inv_max;
+            let left_abs = left.abs();
+            let right_abs = right.abs();
+            if left_abs > peak_left {
+                peak_left = left_abs;
+            }
+            if right_abs > peak_right {
+                peak_right = right_abs;
+            }
+            let l64 = left as f64;
+            let r64 = right as f64;
+            sum_squares_left += l64 * l64;
+            sum_squares_right += r64 * r64;
+        }
+
+        self.peak_left = peak_left;
+        self.peak_right = peak_right;
+
+        let prev_samples = self.total_samples - len;
+        self.rms_left = ((self.rms_left.powi(2) * prev_samples as f64 + sum_squares_left)
+            / self.total_samples as f64)
+            .sqrt();
+        self.rms_right = ((self.rms_right.powi(2) * prev_samples as f64 + sum_squares_right)
+            / self.total_samples as f64)
+            .sqrt();
+    }
+
+    pub fn display(&self) {
+        println!("\n=== Sink Statistics: {} ===", self.name);
+        println!("Chunks received: {}", self.chunks_received);
+        println!("Total samples: {}", self.total_samples);
+        println!("Total duration: {:.3} sec", self.total_duration_sec);
+        println!("Peak L/R: {:.3} / {:.3}", self.peak_left, self.peak_right);
+        println!("RMS L/R: {:.3} / {:.3}", self.rms_left, self.rms_right);
+        println!("========================\n");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    const BD: BitDepth = BitDepth::B24;
+
+    #[tokio::test]
+    async fn test_sink_node_silent() {
+        let (node, tx) = SinkNode::new("test".to_string(), 10);
+
+        let handle = tokio::spawn(async move { node.run_silent().await });
+
+        // Envoyer quelques chunks
+        for i in 0..3 {
+            let chunk = AudioChunk::from_channels_f32(i, vec![0.0; 100], vec![0.0; 100], 48000, BD);
+            tx.send(chunk).await.unwrap();
+        }
+
+        drop(tx);
+        handle.await.unwrap().unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_sink_node_stats() {
+        let (node, tx) = SinkNode::new("test".to_string(), 10);
+
+        let handle = tokio::spawn(async move { node.run_with_stats().await });
+
+        // Envoyer des chunks avec signal connu
+        for i in 0..3 {
+            let chunk =
+                AudioChunk::from_channels_f32(i, vec![1.0; 1000], vec![0.5; 1000], 48000, BD);
+            tx.send(chunk).await.unwrap();
+        }
+
+        drop(tx);
+        let stats = handle.await.unwrap().unwrap();
+
+        assert_eq!(stats.chunks_received, 3);
+        assert_eq!(stats.total_samples, 3000);
+        assert!((stats.peak_left - 1.0).abs() < 1e-6);
+        assert!((stats.peak_right - 0.5).abs() < 1e-6);
+        assert!((stats.rms_left - 1.0).abs() < 0.001);
+        assert!((stats.rms_right - 0.5).abs() < 0.001);
+    }
+
+    #[tokio::test]
+    async fn test_sink_node_file_writer() {
+        let (node, tx) = SinkNode::new("writer".to_string(), 10);
+
+        let handle = tokio::spawn(async move { node.run_mock_file_writer().await });
+
+        // Envoyer des chunks
+        for i in 0..5 {
+            let chunk = AudioChunk::from_channels_f32(i, vec![0.0; 100], vec![0.0; 100], 48000, BD);
+            tx.send(chunk).await.unwrap();
+        }
+
+        drop(tx);
+        let total_samples = handle.await.unwrap().unwrap();
+
+        assert_eq!(total_samples, 500);
+    }
+}

old_code/pmoaudio/nodes/source_node.rs

@@ -0,0 +1,171 @@
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk, BitDepth,
+};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// SourceNode - Génère ou lit des chunks audio depuis une source
+///
+/// Ce node est la source du pipeline. Version mock pour tests.
+pub struct SourceNode {
+    subscribers: MultiSubscriberNode,
+}
+
+const DEFAULT_BIT_DEPTH: BitDepth = BitDepth::B24;
+
+impl SourceNode {
+    pub fn new() -> Self {
+        Self {
+            subscribers: MultiSubscriberNode::new(),
+        }
+    }
+
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.subscribers.add_subscriber(tx);
+    }
+
+    /// Génère un chunk de test avec une forme d'onde sinusoïdale
+    pub fn generate_test_chunk(
+        order: u64,
+        size: usize,
+        sample_rate: u32,
+        frequency: f32,
+    ) -> Arc<AudioChunk> {
+        let mut left = Vec::with_capacity(size);
+        let mut right = Vec::with_capacity(size);
+
+        for i in 0..size {
+            let t = (order * size as u64 + i as u64) as f32 / sample_rate as f32;
+            let sample = (2.0 * std::f32::consts::PI * frequency * t).sin();
+            left.push(sample);
+            right.push(sample * 0.8); // Légèrement différent pour la stéréo
+        }
+
+        AudioChunk::from_channels_f32(order, left, right, sample_rate, DEFAULT_BIT_DEPTH)
+    }
+
+    /// Génère et envoie des chunks de test
+    pub async fn generate_chunks(
+        &self,
+        count: u64,
+        chunk_size: usize,
+        sample_rate: u32,
+        frequency: f32,
+    ) -> Result<(), AudioError> {
+        for i in 0..count {
+            let chunk = Self::generate_test_chunk(i, chunk_size, sample_rate, frequency);
+            self.subscribers.push(chunk).await?;
+        }
+        Ok(())
+    }
+
+    /// Génère des chunks silencieux
+    pub async fn generate_silence(
+        &self,
+        count: u64,
+        chunk_size: usize,
+        sample_rate: u32,
+    ) -> Result<(), AudioError> {
+        for i in 0..count {
+            let stereo = vec![[0i32; 2]; chunk_size];
+            let chunk = AudioChunk::new(i, stereo, sample_rate, DEFAULT_BIT_DEPTH);
+            self.subscribers.push(chunk).await?;
+        }
+        Ok(())
+    }
+
+    /// Version streaming : génère des chunks continuellement avec délai
+    pub async fn stream_chunks(
+        &self,
+        chunk_size: usize,
+        sample_rate: u32,
+        frequency: f32,
+        duration_ms: u64,
+    ) -> Result<(), AudioError> {
+        let chunk_duration_ms = (chunk_size as f64 / sample_rate as f64 * 1000.0) as u64;
+        let mut order = 0u64;
+
+        let start = tokio::time::Instant::now();
+        let duration = tokio::time::Duration::from_millis(duration_ms);
+
+        while start.elapsed() < duration {
+            let chunk = Self::generate_test_chunk(order, chunk_size, sample_rate, frequency);
+            self.subscribers.push(chunk).await?;
+
+            order += 1;
+
+            // Attendre pour simuler le timing réel
+            tokio::time::sleep(tokio::time::Duration::from_millis(chunk_duration_ms)).await;
+        }
+
+        Ok(())
+    }
+}
+
+impl Default for SourceNode {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_source_node_generation() {
+        let mut source = SourceNode::new();
+        let (tx, mut rx) = mpsc::channel(10);
+
+        source.add_subscriber(tx);
+
+        // Générer 3 chunks
+        source.generate_chunks(3, 100, 48000, 440.0).await.unwrap();
+
+        // Vérifier la réception
+        for i in 0..3 {
+            let chunk = rx.recv().await.unwrap();
+            assert_eq!(chunk.order(), i);
+            assert_eq!(chunk.len(), 100);
+            assert_eq!(chunk.sample_rate(), 48000);
+        }
+    }
+
+    #[test]
+    fn test_sine_wave_generation() {
+        let chunk = SourceNode::generate_test_chunk(0, 48000, 48000, 440.0);
+
+        // Vérifier qu'on a bien une sinusoïde
+        // À 440 Hz avec 48000 samples/s, on devrait avoir 440 cycles
+        let pairs = chunk.to_pairs_f32();
+        let left: Vec<f32> = pairs.iter().map(|frame| frame[0]).collect();
+
+        // Trouver les passages par zéro
+        let mut zero_crossings = 0;
+        for i in 1..left.len() {
+            if (left[i - 1] < 0.0 && left[i] >= 0.0) || (left[i - 1] >= 0.0 && left[i] < 0.0) {
+                zero_crossings += 1;
+            }
+        }
+
+        // 440 cycles = 880 passages par zéro (approximativement)
+        assert!(zero_crossings > 850 && zero_crossings < 910);
+    }
+
+    #[tokio::test]
+    async fn test_source_node_silence() {
+        let mut source = SourceNode::new();
+        let (tx, mut rx) = mpsc::channel(10);
+
+        source.add_subscriber(tx);
+
+        source.generate_silence(2, 100, 48000).await.unwrap();
+
+        for _ in 0..2 {
+            let chunk = rx.recv().await.unwrap();
+            assert!(chunk.frames().iter().all(|frame| frame[0] == 0));
+            assert!(chunk.frames().iter().all(|frame| frame[1] == 0));
+        }
+    }
+}

old_code/pmoaudio/nodes/timer_node.rs

@@ -0,0 +1,291 @@
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
+use std::sync::Arc;
+use tokio::sync::{mpsc, RwLock};
+
+/// TimerNode - Node passthrough qui calcule la position temporelle
+///
+/// Ce node ne modifie pas les données audio, il les passe directement
+/// aux abonnés tout en maintenant un compteur de samples pour calculer
+/// la position en secondes.
+///
+/// # Fonctionnement
+///
+/// Pour chaque chunk reçu:
+/// 1. Incrémente `elapsed_samples += chunk.len()`
+/// 2. Calcule `position_sec = elapsed_samples / sample_rate`
+/// 3. Push le chunk (sans modification) vers les abonnés
+///
+/// # Utilisation
+///
+/// Le TimerNode fournit un [`TimerHandle`] qui permet de lire la position
+/// depuis d'autres threads/tasks sans bloquer le pipeline.
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::TimerNode;
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let (mut timer, timer_tx) = TimerNode::new(10);
+///     let handle = timer.get_position_handle();
+///
+///     tokio::spawn(async move {
+///         timer.run().await.unwrap();
+///     });
+///
+///     // Lire la position depuis un autre thread
+///     let position = handle.position_sec().await;
+///     println!("Position: {:.2} sec", position);
+/// }
+/// ```
+pub struct TimerNode {
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+    subscribers: MultiSubscriberNode,
+    elapsed_samples: Arc<RwLock<u64>>,
+    current_sample_rate: Arc<RwLock<u32>>,
+}
+
+impl TimerNode {
+    /// Crée un nouveau TimerNode
+    pub fn new(channel_size: usize) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let node = Self {
+            rx,
+            subscribers: MultiSubscriberNode::new(),
+            elapsed_samples: Arc::new(RwLock::new(0)),
+            current_sample_rate: Arc::new(RwLock::new(48000)), // Default
+        };
+
+        (node, tx)
+    }
+
+    /// Ajoute un abonné
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.subscribers.add_subscriber(tx);
+    }
+
+    /// Retourne la position actuelle en secondes
+    pub async fn position_sec(&self) -> f64 {
+        let elapsed = *self.elapsed_samples.read().await;
+        let sample_rate = *self.current_sample_rate.read().await;
+        elapsed as f64 / sample_rate as f64
+    }
+
+    /// Retourne le nombre total d'échantillons écoulés
+    pub async fn elapsed_samples(&self) -> u64 {
+        *self.elapsed_samples.read().await
+    }
+
+    /// Reset le compteur
+    pub async fn reset(&self) {
+        let mut elapsed = self.elapsed_samples.write().await;
+        *elapsed = 0;
+    }
+
+    /// Démarre la boucle de traitement du TimerNode
+    pub async fn run(mut self) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            // Mettre à jour le sample rate si nécessaire
+            {
+                let mut sr = self.current_sample_rate.write().await;
+                if *sr != chunk.sample_rate() {
+                    *sr = chunk.sample_rate();
+                }
+            }
+
+            // Incrémenter le compteur d'échantillons
+            {
+                let mut elapsed = self.elapsed_samples.write().await;
+                *elapsed += chunk.len() as u64;
+            }
+
+            // Push immédiatement le même chunk vers les abonnés (passthrough)
+            self.subscribers.push(chunk).await?;
+        }
+
+        Ok(())
+    }
+
+    /// Version non-bloquante avec try_push
+    pub async fn run_nonblocking(mut self) -> Result<(), AudioError> {
+        while let Some(chunk) = self.rx.recv().await {
+            {
+                let mut sr = self.current_sample_rate.write().await;
+                if *sr != chunk.sample_rate() {
+                    *sr = chunk.sample_rate();
+                }
+            }
+
+            {
+                let mut elapsed = self.elapsed_samples.write().await;
+                *elapsed += chunk.len() as u64;
+            }
+
+            self.subscribers.try_push(chunk).await?;
+        }
+
+        Ok(())
+    }
+
+    /// Retourne un handle pour lire la position depuis d'autres threads
+    pub fn get_position_handle(&self) -> TimerHandle {
+        TimerHandle {
+            elapsed_samples: self.elapsed_samples.clone(),
+            current_sample_rate: self.current_sample_rate.clone(),
+        }
+    }
+}
+
+/// Handle pour lire la position du TimerNode depuis d'autres threads
+///
+/// Ce handle peut être cloné et utilisé depuis plusieurs threads/tasks
+/// pour monitorer la position de lecture sans bloquer le pipeline.
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::TimerNode;
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let (mut timer, _tx) = TimerNode::new(10);
+///     let handle = timer.get_position_handle();
+///     let handle_clone = handle.clone();
+///
+///     // Utiliser depuis plusieurs tasks
+///     tokio::spawn(async move {
+///         loop {
+///             let pos = handle_clone.position_sec().await;
+///             println!("Position: {:.2}s", pos);
+///             tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+///         }
+///     });
+/// }
+/// ```
+#[derive(Clone)]
+pub struct TimerHandle {
+    elapsed_samples: Arc<RwLock<u64>>,
+    current_sample_rate: Arc<RwLock<u32>>,
+}
+
+impl TimerHandle {
+    /// Retourne la position actuelle en secondes
+    pub async fn position_sec(&self) -> f64 {
+        let elapsed = *self.elapsed_samples.read().await;
+        let sample_rate = *self.current_sample_rate.read().await;
+        elapsed as f64 / sample_rate as f64
+    }
+
+    /// Retourne le nombre total d'échantillons écoulés
+    pub async fn elapsed_samples(&self) -> u64 {
+        *self.elapsed_samples.read().await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_timer_node_position_calculation() {
+        let (mut node, tx) = TimerNode::new(10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        let handle = node.get_position_handle();
+
+        // Spawn le node
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer 3 chunks de 1000 samples à 48000 Hz
+        for i in 0..3 {
+            let stereo = vec![[0i32; 2]; 1000];
+            let chunk = AudioChunk::new(i, stereo, 48000, BitDepth::B24);
+            tx.send(chunk).await.unwrap();
+        }
+
+        // Attendre que les chunks soient traités
+        for _ in 0..3 {
+            out_rx.recv().await.unwrap();
+        }
+
+        // Vérifier la position
+        let position = handle.position_sec().await;
+        let expected = 3000.0 / 48000.0; // 3 chunks * 1000 samples / 48000 Hz
+        assert!((position - expected).abs() < 0.0001);
+
+        let elapsed = handle.elapsed_samples().await;
+        assert_eq!(elapsed, 3000);
+    }
+
+    #[tokio::test]
+    async fn test_timer_node_passthrough() {
+        let (mut node, tx) = TimerNode::new(10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Envoyer un chunk
+        let chunk = AudioChunk::from_channels_i32(
+            42,
+            vec![100, 200, 300],
+            vec![400, 500, 600],
+            48000,
+            BitDepth::B24,
+        );
+        tx.send(chunk.clone()).await.unwrap();
+
+        // Recevoir le chunk
+        let received = out_rx.recv().await.unwrap();
+
+        // Vérifier que c'est le même Arc (pas de clone des données)
+        assert!(Arc::ptr_eq(&chunk, &received));
+        assert_eq!(received.order(), 42);
+    }
+
+    #[tokio::test]
+    async fn test_timer_node_sample_rate_change() {
+        let (mut node, tx) = TimerNode::new(10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        let handle = node.get_position_handle();
+
+        tokio::spawn(async move {
+            node.run().await.unwrap();
+        });
+
+        // Chunk à 48000 Hz
+        let chunk1 = AudioChunk::new(0, vec![[0i32; 2]; 48000], 48000, BitDepth::B24);
+        tx.send(chunk1).await.unwrap();
+        out_rx.recv().await.unwrap();
+
+        // Après 48000 samples à 48000 Hz = 1 seconde
+        let pos1 = handle.position_sec().await;
+        assert!((pos1 - 1.0).abs() < 0.0001);
+
+        // Chunk à 96000 Hz
+        let chunk2 = AudioChunk::new(1, vec![[0i32; 2]; 96000], 96000, BitDepth::B24);
+        tx.send(chunk2).await.unwrap();
+        out_rx.recv().await.unwrap();
+
+        // Position calculée avec le nouveau sample rate
+        let pos2 = handle.position_sec().await;
+        let expected = (48000.0 + 96000.0) / 96000.0;
+        assert!((pos2 - expected).abs() < 0.0001);
+    }
+}

old_code/pmoaudio/nodes/volume_node.rs

@@ -0,0 +1,363 @@
+//! Volume nodes - Contrôle du volume audio
+//!
+//! Ce module fournit des nodes pour ajuster le volume du flux audio,
+//! avec support du volume master/secondaire et notification des changements.
+
+use crate::{
+    events::{EventPublisher, VolumeChangeEvent},
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
+use std::sync::Arc;
+use tokio::sync::{mpsc, RwLock};
+
+/// VolumeNode - Applique un gain au flux audio (contrôle software)
+///
+/// Ce node modifie le champ `gain` de chaque `AudioChunk` qui le traverse.
+/// Le gain est multiplié avec le gain existant du chunk, permettant ainsi
+/// une chaîne de contrôles de volume.
+///
+/// # Caractéristiques
+///
+/// - Thread-safe : le volume peut être modifié pendant l'exécution via `set_volume`
+/// - Notification : émet des événements `VolumeChangeEvent` lors des changements
+/// - Master/Slave : peut s'abonner à un volume master pour synchronisation
+///
+/// # Exemples
+///
+/// ```no_run
+/// use pmoaudio::VolumeNode;
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let (volume_node, volume_tx) = VolumeNode::new("Room 1".to_string(), 0.8, 10);
+///
+///     // Modifier le volume pendant l'exécution
+///     let handle = volume_node.get_handle();
+///     tokio::spawn(async move {
+///         tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+///         handle.set_volume(0.5).await;
+///     });
+///
+///     tokio::spawn(async move { volume_node.run().await.unwrap() });
+/// }
+/// ```
+pub struct VolumeNode {
+    /// Channel pour recevoir les chunks audio
+    rx: mpsc::Receiver<Arc<AudioChunk>>,
+
+    /// Subscribers pour les chunks modifiés
+    subscribers: MultiSubscriberNode,
+
+    /// Volume courant (partagé via RwLock pour lecture/écriture thread-safe)
+    volume: Arc<RwLock<f32>>,
+
+    /// Publisher pour les événements de changement de volume
+    volume_publisher: EventPublisher<VolumeChangeEvent>,
+
+    /// Identifiant unique du node (pour traçabilité)
+    node_id: String,
+
+    /// Receiver pour les événements de volume master (optionnel)
+    master_volume_rx: Option<mpsc::Receiver<VolumeChangeEvent>>,
+}
+
+impl VolumeNode {
+    /// Crée un nouveau VolumeNode
+    ///
+    /// # Arguments
+    ///
+    /// * `node_id` - Identifiant unique du node
+    /// * `initial_volume` - Volume initial (0.0 à 1.0)
+    /// * `channel_size` - Taille du buffer du channel
+    pub fn new(
+        node_id: String,
+        initial_volume: f32,
+        channel_size: usize,
+    ) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (tx, rx) = mpsc::channel(channel_size);
+
+        let node = Self {
+            rx,
+            subscribers: MultiSubscriberNode::new(),
+            volume: Arc::new(RwLock::new(initial_volume)),
+            volume_publisher: EventPublisher::new(),
+            node_id,
+            master_volume_rx: None,
+        };
+
+        (node, tx)
+    }
+
+    /// Ajoute un subscriber pour recevoir les chunks audio modifiés
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.subscribers.add_subscriber(tx);
+    }
+
+    /// Ajoute un subscriber pour les événements de changement de volume
+    pub fn subscribe_volume_events(&mut self, tx: mpsc::Sender<VolumeChangeEvent>) {
+        self.volume_publisher.subscribe(tx);
+    }
+
+    /// Configure ce node pour écouter un volume master
+    ///
+    /// Le node appliquera à la fois son volume local ET le volume master reçu.
+    pub fn set_master_volume_source(&mut self, rx: mpsc::Receiver<VolumeChangeEvent>) {
+        self.master_volume_rx = Some(rx);
+    }
+
+    /// Retourne un handle pour contrôler le volume depuis un autre contexte
+    pub fn get_handle(&self) -> VolumeHandle {
+        VolumeHandle {
+            volume: self.volume.clone(),
+            node_id: self.node_id.clone(),
+            publisher: Arc::new(RwLock::new(self.volume_publisher.clone())),
+        }
+    }
+
+    /// Démarre la boucle de traitement du VolumeNode
+    pub async fn run(mut self) -> Result<(), AudioError> {
+        let mut master_volume = 1.0f32;
+
+        loop {
+            tokio::select! {
+                // Recevoir les chunks audio
+                chunk_opt = self.rx.recv() => {
+                    match chunk_opt {
+                        Some(chunk) => {
+                            let local_volume = *self.volume.read().await;
+                            let total_volume = (local_volume * master_volume).max(0.0);
+
+                            // Créer un nouveau chunk avec le gain modifié (conversion vers dB)
+                            let modified_chunk =
+                                chunk.with_modified_gain_linear(total_volume as f64);
+
+                            // Envoyer aux subscribers
+                            self.subscribers.push(modified_chunk).await?;
+                        }
+                        None => {
+                            // Channel fermé, terminer
+                            break;
+                        }
+                    }
+                }
+
+                // Recevoir les mises à jour du volume master (si configuré)
+                master_event_opt = async {
+                    if let Some(ref mut rx) = self.master_volume_rx {
+                        rx.recv().await
+                    } else {
+                        // Bloquer indéfiniment si pas de master
+                        std::future::pending().await
+                    }
+                } => {
+                    if let Some(event) = master_event_opt {
+                        master_volume = event.volume;
+
+                        // Optionnel : re-publier l'événement combiné
+                        let local_volume = *self.volume.read().await;
+                        let combined_event = VolumeChangeEvent {
+                            volume: local_volume * master_volume,
+                            source_node_id: self.node_id.clone(),
+                        };
+                        self.volume_publisher.publish(combined_event).await;
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Handle pour contrôler un VolumeNode depuis un autre contexte
+///
+/// Ce handle permet de modifier le volume et de notifier les subscribers
+/// sans avoir accès direct au node.
+#[derive(Clone)]
+pub struct VolumeHandle {
+    volume: Arc<RwLock<f32>>,
+    node_id: String,
+    publisher: Arc<RwLock<EventPublisher<VolumeChangeEvent>>>,
+}
+
+impl VolumeHandle {
+    /// Modifie le volume
+    ///
+    /// # Arguments
+    ///
+    /// * `new_volume` - Nouveau volume (0.0 à 1.0)
+    pub async fn set_volume(&self, new_volume: f32) {
+        let clamped = new_volume.clamp(0.0, 1.0);
+        *self.volume.write().await = clamped;
+
+        // Publier l'événement de changement
+        let event = VolumeChangeEvent {
+            volume: clamped,
+            source_node_id: self.node_id.clone(),
+        };
+
+        self.publisher.read().await.publish(event).await;
+    }
+
+    /// Obtient le volume courant
+    pub async fn get_volume(&self) -> f32 {
+        *self.volume.read().await
+    }
+
+    /// Augmente le volume de manière relative
+    pub async fn adjust_volume(&self, delta: f32) {
+        let current = *self.volume.read().await;
+        self.set_volume(current + delta).await;
+    }
+}
+
+/// HardwareVolumeNode - Contrôle matériel du volume
+///
+/// Ce node simule un contrôle hardware du volume. Dans une implémentation réelle,
+/// il communiquerait avec le driver audio pour ajuster le volume matériel.
+///
+/// Pour cette version, il agit de manière similaire à `VolumeNode` mais pourrait
+/// être étendu pour utiliser des APIs système spécifiques.
+pub struct HardwareVolumeNode {
+    inner: VolumeNode,
+}
+
+impl HardwareVolumeNode {
+    /// Crée un nouveau HardwareVolumeNode
+    pub fn new(
+        node_id: String,
+        initial_volume: f32,
+        channel_size: usize,
+    ) -> (Self, mpsc::Sender<Arc<AudioChunk>>) {
+        let (inner, tx) = VolumeNode::new(node_id, initial_volume, channel_size);
+
+        (Self { inner }, tx)
+    }
+
+    /// Ajoute un subscriber
+    pub fn add_subscriber(&mut self, tx: mpsc::Sender<Arc<AudioChunk>>) {
+        self.inner.add_subscriber(tx);
+    }
+
+    /// Obtient un handle pour contrôler le volume
+    pub fn get_handle(&self) -> VolumeHandle {
+        self.inner.get_handle()
+    }
+
+    /// Démarre la boucle de traitement
+    pub async fn run(self) -> Result<(), AudioError> {
+        // Dans une vraie implémentation, on communiquerait avec le hardware ici
+        // Pour l'instant, délègue au VolumeNode standard
+        self.inner.run().await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BitDepth;
+
+    #[tokio::test]
+    async fn test_volume_node_basic() {
+        let (mut node, tx) = VolumeNode::new("test".to_string(), 0.5, 10);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+
+        node.add_subscriber(out_tx);
+
+        let handle = tokio::spawn(async move { node.run().await });
+
+        // Envoyer un chunk avec gain 1.0
+        let chunk =
+            AudioChunk::from_channels_f32(0, vec![1.0; 100], vec![1.0; 100], 48000, BitDepth::B24);
+        tx.send(chunk).await.unwrap();
+
+        // Recevoir le chunk modifié
+        let modified = out_rx.recv().await.unwrap();
+        assert!((modified.gain_linear() - 0.5).abs() < 1e-6);
+
+        drop(tx);
+        handle.await.unwrap().unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_volume_handle() {
+        let (node, tx) = VolumeNode::new("test".to_string(), 1.0, 10);
+        let handle = node.get_handle();
+
+        tokio::spawn(async move { node.run().await });
+
+        // Modifier le volume via le handle
+        handle.set_volume(0.3).await;
+
+        let volume = handle.get_volume().await;
+        assert!((volume - 0.3).abs() < f32::EPSILON);
+
+        drop(tx);
+    }
+
+    #[tokio::test]
+    async fn test_volume_events() {
+        let (mut node, tx) = VolumeNode::new("test".to_string(), 1.0, 10);
+        let (event_tx, mut event_rx) = mpsc::channel(10);
+
+        node.subscribe_volume_events(event_tx);
+        let handle = node.get_handle();
+
+        tokio::spawn(async move { node.run().await });
+
+        // Changer le volume
+        handle.set_volume(0.7).await;
+
+        // Vérifier l'événement
+        let event = event_rx.recv().await.unwrap();
+        assert!((event.volume - 0.7).abs() < f32::EPSILON);
+        assert_eq!(event.source_node_id, "test");
+
+        drop(tx);
+    }
+
+    #[tokio::test]
+    async fn test_master_slave_volume() {
+        // Créer le master
+        let (mut master, master_tx) = VolumeNode::new("master".to_string(), 1.0, 10);
+        let (master_event_tx, master_event_rx) = mpsc::channel(10);
+        master.subscribe_volume_events(master_event_tx);
+        let master_handle = master.get_handle();
+
+        // Créer le slave
+        let (mut slave, slave_tx) = VolumeNode::new("slave".to_string(), 0.8, 10);
+        slave.set_master_volume_source(master_event_rx);
+        let (out_tx, mut out_rx) = mpsc::channel(10);
+        slave.add_subscriber(out_tx);
+
+        tokio::spawn(async move { master.run().await });
+        tokio::spawn(async move { slave.run().await });
+
+        // Envoyer un chunk au slave
+        let chunk =
+            AudioChunk::from_channels_f32(0, vec![1.0; 100], vec![1.0; 100], 48000, BitDepth::B24);
+        slave_tx.send(chunk).await.unwrap();
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+
+        // Modifier le volume master
+        master_handle.set_volume(0.5).await;
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+
+        // Envoyer un autre chunk
+        let chunk2 =
+            AudioChunk::from_channels_f32(1, vec![1.0; 100], vec![1.0; 100], 48000, BitDepth::B24);
+        slave_tx.send(chunk2).await.unwrap();
+
+        // Le deuxième chunk devrait avoir un gain de 0.8 * 0.5 = 0.4 (≈ -7.96 dB)
+        let _first = out_rx.recv().await.unwrap(); // gain ≈ 0.8
+        let second = out_rx.recv().await.unwrap(); // gain ≈ 0.4
+
+        assert!((second.gain_linear() - 0.4).abs() < 0.01);
+
+        drop(master_tx);
+        drop(slave_tx);
+    }
+}

old_code/pmoplaylist/examples/basic_usage.rs

@@ -0,0 +1,170 @@
+//! Exemple d'utilisation basique de pmoplaylist
+//!
+//! Pour exécuter cet exemple :
+//! ```bash
+//! cargo run -p pmoplaylist --example basic_usage
+//! ```
+
+use pmoplaylist::{FifoPlaylist, Track, DEFAULT_IMAGE};
+
+#[tokio::main]
+async fn main() {
+    println!("=== Exemple pmoplaylist ===\n");
+
+    // 1. Créer une playlist FIFO
+    println!("1. Création d'une playlist avec capacité de 5 tracks...");
+    let playlist = FifoPlaylist::new(
+        "my-radio".to_string(),
+        "Ma Radio Préférée".to_string(),
+        5,
+        DEFAULT_IMAGE,
+    );
+    println!("   ✓ Playlist créée: {}", playlist.title().await);
+    println!("   ✓ ID: {}", playlist.id().await);
+    println!("   ✓ Capacité: 5 tracks");
+    println!("   ✓ Update ID initial: {}\n", playlist.update_id().await);
+
+    // 2. Ajouter des tracks
+    println!("2. Ajout de 3 tracks...");
+    let tracks = vec![
+        Track::new(
+            "track-1",
+            "Bohemian Rhapsody",
+            "http://example.com/queen/bohemian.flac",
+        )
+        .with_artist("Queen")
+        .with_album("A Night at the Opera")
+        .with_duration(354)
+        .with_image("http://example.com/covers/queen-anato.jpg"),
+        Track::new(
+            "track-2",
+            "Stairway to Heaven",
+            "http://example.com/zeppelin/stairway.mp3",
+        )
+        .with_artist("Led Zeppelin")
+        .with_album("Led Zeppelin IV")
+        .with_duration(482),
+        Track::new(
+            "track-3",
+            "Hotel California",
+            "http://example.com/eagles/hotel.flac",
+        )
+        .with_artist("Eagles")
+        .with_album("Hotel California")
+        .with_duration(391),
+    ];
+
+    for track in tracks {
+        playlist.append_track(track.clone()).await;
+        println!(
+            "   ✓ Ajouté: {} - {}",
+            track.title,
+            track.artist.unwrap_or_default()
+        );
+    }
+
+    println!("\n   Total tracks: {}", playlist.len().await);
+    println!("   Update ID: {}\n", playlist.update_id().await);
+
+    // 3. Tester le comportement FIFO
+    println!("3. Test du comportement FIFO (capacité = 5)...");
+    println!("   Ajout de 4 tracks supplémentaires...");
+
+    for i in 4..=7 {
+        let track = Track::new(
+            format!("track-{}", i),
+            format!("Song Number {}", i),
+            format!("http://example.com/songs/{}.mp3", i),
+        );
+        playlist.append_track(track).await;
+    }
+
+    println!(
+        "   ✓ Total tracks (limité par capacité): {}",
+        playlist.len().await
+    );
+
+    // Afficher les tracks actuels
+    let items = playlist.get_items(0, 10).await;
+    println!("\n   Tracks actuels dans la FIFO:");
+    for (idx, track) in items.iter().enumerate() {
+        println!("     {}. {} ({})", idx + 1, track.title, track.id);
+    }
+    println!("   (Les tracks 1 et 2 ont été supprimés automatiquement)\n");
+
+    // 4. Supprimer le plus ancien
+    println!("4. Suppression du track le plus ancien...");
+    if let Some(removed) = playlist.remove_oldest().await {
+        println!("   ✓ Supprimé: {} ({})", removed.title, removed.id);
+    }
+    println!("   Total tracks: {}", playlist.len().await);
+    println!("   Update ID: {}\n", playlist.update_id().await);
+
+    // 5. Supprimer par ID
+    println!("5. Suppression d'un track par ID (track-5)...");
+    if playlist.remove_by_id("track-5").await {
+        println!("   ✓ Track supprimé");
+    }
+    println!("   Total tracks: {}", playlist.len().await);
+    println!("   Update ID: {}\n", playlist.update_id().await);
+
+    // 6. Générer un Container DIDL-Lite
+    println!("6. Génération du Container DIDL-Lite...");
+    let container = playlist.as_container().await;
+    println!("   Container:");
+    println!("     - ID: {}", container.id);
+    println!("     - Parent ID: {}", container.parent_id);
+    println!("     - Title: {}", container.title);
+    println!("     - Class: {}", container.class);
+    println!(
+        "     - Child Count: {}\n",
+        container.child_count.unwrap_or_default()
+    );
+
+    // 7. Générer des Items DIDL-Lite
+    println!("7. Génération des Items DIDL-Lite...");
+    let didl_items = playlist
+        .as_objects(0, 10, Some("http://myserver/api/default-image"))
+        .await;
+
+    println!("   Items DIDL-Lite:");
+    for (idx, item) in didl_items.iter().enumerate() {
+        println!("\n   Item {}:", idx + 1);
+        println!("     - ID: {}", item.id);
+        println!("     - Title: {}", item.title);
+        println!("     - Artist: {}", item.artist.as_deref().unwrap_or("N/A"));
+        println!("     - Album: {}", item.album.as_deref().unwrap_or("N/A"));
+        println!("     - Class: {}", item.class);
+        println!("     - Parent ID: {}", item.parent_id);
+
+        if !item.resources.is_empty() {
+            println!("     - Resource URI: {}", item.resources[0].url);
+            if let Some(ref duration) = item.resources[0].duration {
+                println!("     - Duration: {}", duration);
+            }
+        }
+
+        if let Some(ref art) = item.album_art {
+            println!("     - Album Art: {}", art);
+        }
+    }
+
+    // 8. Image par défaut
+    println!("\n8. Image par défaut...");
+    let default_image = playlist.default_image().await;
+    println!(
+        "   ✓ Taille de l'image par défaut: {} bytes",
+        default_image.len()
+    );
+    println!("   (Cette image peut être servie via un endpoint HTTP)\n");
+
+    // 9. Vider la playlist
+    println!("9. Vidage de la playlist...");
+    playlist.clear().await;
+    println!("   ✓ Playlist vidée");
+    println!("   Total tracks: {}", playlist.len().await);
+    println!("   Is empty: {}", playlist.is_empty().await);
+    println!("   Update ID final: {}\n", playlist.update_id().await);
+
+    println!("=== Exemple terminé ===");
+}

old_code/pmoplaylist/examples/http_server_integration.rs

@@ -0,0 +1,217 @@
+//! Exemple d'intégration avec un serveur HTTP
+//!
+//! Cet exemple montre comment exposer une playlist FIFO via des endpoints HTTP simples.
+//! Dans un vrai MediaServer UPnP, ces endpoints seraient appelés par le protocole ContentDirectory.
+//!
+//! Pour exécuter :
+//! ```bash
+//! cargo run -p pmoplaylist --example http_server_integration
+//! ```
+
+use pmoplaylist::{FifoPlaylist, Track, DEFAULT_IMAGE};
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() {
+    println!("=== Intégration HTTP Server ===\n");
+
+    // Créer une playlist partagée
+    let playlist = Arc::new(FifoPlaylist::new(
+        "my-radio".to_string(),
+        "My Internet Radio".to_string(),
+        20,
+        DEFAULT_IMAGE,
+    ));
+
+    println!("📻 Playlist créée: {}", playlist.title().await);
+    println!("🆔 ID: {}\n", playlist.id().await);
+
+    // Ajouter quelques tracks initiaux
+    println!("📝 Ajout de tracks initiaux...");
+    let initial_tracks = vec![
+        ("The Beatles", "Come Together", "Abbey Road", 259),
+        ("Nirvana", "Smells Like Teen Spirit", "Nevermind", 301),
+        ("Queen", "Bohemian Rhapsody", "A Night at the Opera", 354),
+    ];
+
+    for (idx, (artist, title, album, duration)) in initial_tracks.iter().enumerate() {
+        playlist
+            .append_track(
+                Track::new(
+                    format!("track-{}", idx),
+                    *title,
+                    format!("http://media.server/music/{}.flac", idx),
+                )
+                .with_artist(*artist)
+                .with_album(*album)
+                .with_duration(*duration)
+                .with_image(format!("http://media.server/covers/{}.jpg", idx)),
+            )
+            .await;
+        println!("  ✓ {} - {}", artist, title);
+    }
+    println!();
+
+    // Simuler différents endpoints HTTP
+
+    // 1. GET /playlist/container - Retourne le container DIDL-Lite
+    println!("🌐 Endpoint: GET /playlist/container");
+    simulate_get_container(playlist.clone()).await;
+    println!();
+
+    // 2. GET /playlist/items?offset=0&count=10 - Retourne les items
+    println!("🌐 Endpoint: GET /playlist/items?offset=0&count=10");
+    simulate_get_items(playlist.clone(), 0, 10).await;
+    println!();
+
+    // 3. GET /playlist/metadata - Retourne les métadonnées
+    println!("🌐 Endpoint: GET /playlist/metadata");
+    simulate_get_metadata(playlist.clone()).await;
+    println!();
+
+    // 4. POST /playlist/track - Ajoute un nouveau track
+    println!("🌐 Endpoint: POST /playlist/track");
+    let new_track = Track::new(
+        "track-new-1",
+        "Stairway to Heaven",
+        "http://media.server/music/stairway.flac",
+    )
+    .with_artist("Led Zeppelin")
+    .with_album("Led Zeppelin IV")
+    .with_duration(482);
+
+    simulate_add_track(playlist.clone(), new_track).await;
+    println!();
+
+    // 5. DELETE /playlist/oldest - Supprime le plus ancien
+    println!("🌐 Endpoint: DELETE /playlist/oldest");
+    simulate_delete_oldest(playlist.clone()).await;
+    println!();
+
+    // 6. GET /playlist/default-image - Retourne l'image par défaut
+    println!("🌐 Endpoint: GET /playlist/default-image");
+    simulate_get_default_image(playlist.clone()).await;
+    println!();
+
+    // 7. Vérifier l'état final
+    println!("📊 État final:");
+    let final_items = playlist.get_items(0, 10).await;
+    println!("  Total tracks: {}", playlist.len().await);
+    println!("  Update ID: {}", playlist.update_id().await);
+    println!("\n  Tracks actuels:");
+    for (idx, track) in final_items.iter().enumerate() {
+        let artist = track.artist.as_deref().unwrap_or("Unknown");
+        println!("    {}. {} - {}", idx + 1, artist, track.title);
+    }
+
+    println!("\n=== Exemple terminé ===");
+}
+
+/// Simule GET /playlist/container
+async fn simulate_get_container(playlist: Arc<FifoPlaylist>) {
+    let container = playlist.as_container().await;
+
+    println!("  Response (JSON representation):");
+    println!("  {{");
+    println!("    \"id\": \"{}\",", container.id);
+    println!("    \"parentId\": \"{}\",", container.parent_id);
+    println!("    \"title\": \"{}\",", container.title);
+    println!("    \"class\": \"{}\",", container.class);
+    println!(
+        "    \"childCount\": {}",
+        container.child_count.unwrap_or_default()
+    );
+    println!("  }}");
+}
+
+/// Simule GET /playlist/items?offset=X&count=Y
+async fn simulate_get_items(playlist: Arc<FifoPlaylist>, offset: usize, count: usize) {
+    let items = playlist
+        .as_objects(offset, count, Some("http://media.server/api/default-image"))
+        .await;
+
+    println!("  Response: {} items", items.len());
+    println!("  [");
+    for (idx, item) in items.iter().enumerate() {
+        println!("    {{");
+        println!("      \"id\": \"{}\",", item.id);
+        println!("      \"title\": \"{}\",", item.title);
+        println!(
+            "      \"artist\": \"{}\",",
+            item.artist.as_deref().unwrap_or("")
+        );
+        println!(
+            "      \"album\": \"{}\",",
+            item.album.as_deref().unwrap_or("")
+        );
+        println!("      \"class\": \"{}\",", item.class);
+        if !item.resources.is_empty() {
+            println!("      \"uri\": \"{}\",", item.resources[0].url);
+        }
+        print!("    }}");
+        if idx < items.len() - 1 {
+            println!(",");
+        } else {
+            println!();
+        }
+    }
+    println!("  ]");
+}
+
+/// Simule GET /playlist/metadata
+async fn simulate_get_metadata(playlist: Arc<FifoPlaylist>) {
+    let update_id = playlist.update_id().await;
+    let last_change = playlist.last_change().await;
+    let count = playlist.len().await;
+    let id = playlist.id().await;
+    let title = playlist.title().await;
+
+    println!("  Response:");
+    println!("  {{");
+    println!("    \"id\": \"{}\",", id);
+    println!("    \"title\": \"{}\",", title);
+    println!("    \"trackCount\": {},", count);
+    println!("    \"updateId\": {},", update_id);
+    println!("    \"lastChange\": \"{:?}\"", last_change);
+    println!("  }}");
+}
+
+/// Simule POST /playlist/track
+async fn simulate_add_track(playlist: Arc<FifoPlaylist>, track: Track) {
+    let old_update_id = playlist.update_id().await;
+
+    playlist.append_track(track.clone()).await;
+
+    let new_update_id = playlist.update_id().await;
+
+    println!(
+        "  Track added: {} - {}",
+        track.artist.as_deref().unwrap_or("Unknown"),
+        track.title
+    );
+    println!("  Update ID: {} → {}", old_update_id, new_update_id);
+    println!("  Response: 201 Created");
+}
+
+/// Simule DELETE /playlist/oldest
+async fn simulate_delete_oldest(playlist: Arc<FifoPlaylist>) {
+    if let Some(removed) = playlist.remove_oldest().await {
+        println!("  Track removed: {} ({})", removed.title, removed.id);
+        println!("  New update ID: {}", playlist.update_id().await);
+        println!("  Response: 200 OK");
+    } else {
+        println!("  No tracks to remove");
+        println!("  Response: 404 Not Found");
+    }
+}
+
+/// Simule GET /playlist/default-image
+async fn simulate_get_default_image(playlist: Arc<FifoPlaylist>) {
+    let image_bytes = playlist.default_image().await;
+
+    println!("  Response:");
+    println!("    Content-Type: image/webp");
+    println!("    Content-Length: {} bytes", image_bytes.len());
+    println!("    Status: 200 OK");
+    println!("  (Image WebP {} bytes ready to serve)", image_bytes.len());
+}

old_code/pmoplaylist/examples/radio_streaming.rs

@@ -0,0 +1,198 @@
+//! Exemple simulant une radio en streaming
+//!
+//! Cet exemple démontre :
+//! - L'utilisation de FifoPlaylist dans un contexte multi-thread
+//! - La simulation d'un flux radio continu
+//! - La surveillance des changements via update_id
+//!
+//! Pour exécuter :
+//! ```bash
+//! cargo run -p pmoplaylist --example radio_streaming
+//! ```
+
+use pmoplaylist::{FifoPlaylist, Track, DEFAULT_IMAGE};
+use std::time::Duration;
+use tokio::time::sleep;
+
+#[tokio::main]
+async fn main() {
+    println!("=== Simulation Radio en Streaming ===\n");
+
+    // Créer une radio avec historique limité à 10 tracks
+    let radio = FifoPlaylist::new(
+        "radio-paradise".to_string(),
+        "Radio Paradise - Main Mix".to_string(),
+        10,
+        DEFAULT_IMAGE,
+    );
+
+    println!("📻 Radio créée: {}", radio.title().await);
+    println!("📊 Capacité: 10 tracks (historique limité)");
+    println!("🆔 ID: {}\n", radio.id().await);
+
+    // Cloner pour les différentes tâches
+    let radio_streamer = radio.clone();
+    let radio_monitor = radio.clone();
+    let radio_client = radio.clone();
+
+    // Tâche 1: Simuler le streaming (ajoute des tracks régulièrement)
+    let streamer = tokio::spawn(async move {
+        println!("🎵 [STREAMER] Démarrage du flux radio...\n");
+
+        let tracks_data = vec![
+            ("Radiohead", "Paranoid Android", "OK Computer", 383),
+            ("Massive Attack", "Teardrop", "Mezzanine", 329),
+            (
+                "Pink Floyd",
+                "Shine On You Crazy Diamond",
+                "Wish You Were Here",
+                810,
+            ),
+            ("Portishead", "Glory Box", "Dummy", 305),
+            ("Dire Straits", "Sultans of Swing", "Dire Straits", 349),
+            ("The Cure", "Pictures of You", "Disintegration", 428),
+            ("David Bowie", "Heroes", "Heroes", 371),
+            (
+                "Talking Heads",
+                "Once in a Lifetime",
+                "Remain in Light",
+                259,
+            ),
+            ("Fleetwood Mac", "Dreams", "Rumours", 257),
+            (
+                "The Smiths",
+                "There Is a Light That Never Goes Out",
+                "The Queen Is Dead",
+                244,
+            ),
+            ("Joy Division", "Love Will Tear Us Apart", "Closer", 206),
+            ("New Order", "Blue Monday", "Power, Corruption & Lies", 448),
+            ("Depeche Mode", "Enjoy the Silence", "Violator", 376),
+            ("R.E.M.", "Losing My Religion", "Out of Time", 269),
+            (
+                "U2",
+                "Where the Streets Have No Name",
+                "The Joshua Tree",
+                337,
+            ),
+        ];
+
+        for (idx, (artist, title, album, duration)) in tracks_data.iter().enumerate() {
+            let track = Track::new(
+                format!("radio-track-{}", idx),
+                *title,
+                format!("http://stream.radioparadise.com/track/{}", idx),
+            )
+            .with_artist(*artist)
+            .with_album(*album)
+            .with_duration(*duration);
+
+            radio_streamer.append_track(track).await;
+
+            println!("🎵 [STREAMER] Now Playing: {} - {}", artist, title);
+
+            // Simuler l'attente entre les tracks
+            sleep(Duration::from_millis(500)).await;
+        }
+
+        println!("\n🎵 [STREAMER] Fin du streaming");
+    });
+
+    // Tâche 2: Monitorer les changements (update_id)
+    let monitor = tokio::spawn(async move {
+        sleep(Duration::from_millis(100)).await;
+
+        println!("👁️  [MONITOR] Surveillance des changements...\n");
+
+        let mut last_update_id = 0;
+        let mut iterations = 0;
+
+        loop {
+            let current_update_id = radio_monitor.update_id().await;
+            let count = radio_monitor.len().await;
+
+            if current_update_id != last_update_id {
+                println!(
+                    "👁️  [MONITOR] Changement détecté! Update ID: {} → {} | Tracks: {}",
+                    last_update_id, current_update_id, count
+                );
+                last_update_id = current_update_id;
+            }
+
+            iterations += 1;
+            if iterations >= 50 {
+                break;
+            }
+
+            sleep(Duration::from_millis(200)).await;
+        }
+
+        println!("\n👁️  [MONITOR] Fin de la surveillance");
+    });
+
+    // Tâche 3: Client consultant l'historique
+    let client = tokio::spawn(async move {
+        sleep(Duration::from_millis(2000)).await;
+
+        println!("\n📱 [CLIENT] Consultation de l'historique de la radio...\n");
+
+        // Consulter plusieurs fois pendant le streaming
+        for i in 0..3 {
+            sleep(Duration::from_millis(2000)).await;
+
+            let history = radio_client.get_items(0, 10).await;
+            let update_id = radio_client.update_id().await;
+
+            println!(
+                "📱 [CLIENT] Consultation #{} (Update ID: {})",
+                i + 1,
+                update_id
+            );
+            println!("   Historique actuel ({} tracks):", history.len());
+
+            for (idx, track) in history.iter().enumerate() {
+                let artist = track.artist.as_deref().unwrap_or("Unknown");
+                println!("     {}. {} - {}", idx + 1, artist, track.title);
+            }
+            println!();
+        }
+
+        // Générer le container DIDL-Lite à la fin
+        println!("📱 [CLIENT] Génération du Container DIDL-Lite...");
+        let container = radio_client.as_container().await;
+        println!("   Container ID: {}", container.id);
+        println!("   Title: {}", container.title);
+        println!(
+            "   Child Count: {}",
+            container.child_count.unwrap_or_default()
+        );
+
+        println!("\n📱 [CLIENT] Fin de la consultation");
+    });
+
+    // Attendre que toutes les tâches se terminent
+    let _ = tokio::join!(streamer, monitor, client);
+
+    // Afficher l'état final
+    println!("\n=== État Final ===");
+    println!("📊 Total tracks dans la radio: {}", radio.len().await);
+    println!("🆔 Update ID final: {}", radio.update_id().await);
+
+    let final_history = radio.get_items(0, 10).await;
+    println!("\n🎵 Historique final (10 derniers tracks):");
+    for (idx, track) in final_history.iter().enumerate() {
+        let artist = track.artist.as_deref().unwrap_or("Unknown");
+        let duration_min = track.duration.map(|d| d / 60).unwrap_or(0);
+        let duration_sec = track.duration.map(|d| d % 60).unwrap_or(0);
+        println!(
+            "  {}. {} - {} ({}:{:02})",
+            idx + 1,
+            artist,
+            track.title,
+            duration_min,
+            duration_sec
+        );
+    }
+
+    println!("\n=== Simulation terminée ===");
+}

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "pmomusic",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package.json

@@ -0,0 +1 @@
+{}

pmoapp/Cargo.toml

@@ -5,3 +5,11 @@ edition = "2021"
 
 [dependencies]
 rust-embed = "8.5.0"
+
+[dependencies.pmoserver]
+path = "../pmoserver"
+optional = true
+
+[features]
+default = []
+pmoserver = ["dep:pmoserver"]

pmoapp/Cargo.toml.backup

@@ -0,0 +1,15 @@
+[package]
+name = "pmoapp"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+rust-embed = "8.5.0"
+
+[dependencies.pmoserver]
+path = "../pmoserver"
+optional = true
+
+[features]
+default = []
+pmoserver = ["dep:pmoserver"]

pmoapp/src/lib.rs

@@ -1,30 +1,241 @@
 //! # pmoapp - Application web UPnP pour PMOMusic
 //!
-//! Cette crate fournit l'application web frontend pour le contrôle UPnP,
-//! intégrée via RustEmbed pour être servie par pmoserver.
+//! Cette crate fournit l'application web frontend pour le contrôle et la visualisation
+//! des devices UPnP MediaRenderer, intégrée via RustEmbed pour être servie par pmoserver.
+//!
+//! ## Vue d'ensemble
+//!
+//! `pmoapp` est une application Vue.js 3 moderne avec TypeScript qui offre une interface
+//! utilisateur pour :
+//! - Visualiser les logs système en temps réel (Server-Sent Events)
+//! - Contrôler les devices UPnP MediaRenderer
+//! - Afficher et formater automatiquement le XML dans les logs
 //!
 //! ## Fonctionnalités
 //!
-//! - 📦 **Frontend intégré** : Application web compilée et embarquée dans le binaire
-//! - 🎨 **Interface de contrôle** : UI pour gérer les devices UPnP MediaRenderer
-//! - 🚀 **Zero configuration** : Pas besoin de servir des fichiers statiques séparés
+//! ### 📦 Frontend intégré
+//! - Application web compilée et embarquée dans le binaire Rust
+//! - Aucun fichier statique externe à gérer en production
+//! - Intégration via `RustEmbed` pour une distribution simplifiée
+//!
+//! ### 🎨 Interface utilisateur
+//! - **LogView** : Visualisation des logs en temps réel avec filtres par niveau
+//! - **Auto-scroll** : Défilement automatique des nouveaux logs (désactivable)
+//! - **Formatage XML** : Détection et coloration syntaxique automatique du XML
+//! - **Design responsive** : Compatible desktop et mobile
+//! - **Thème sombre** : Style inspiré de VS Code pour une meilleure lisibilité
+//!
+//! ### 🚀 Zero configuration
+//! - Pas besoin de serveur web séparé pour les assets
+//! - Les fichiers sont servis directement depuis la mémoire du binaire
+//! - Configuration automatique du routing Vue Router
+//!
+//! ## Architecture
+//!
+//! ### Stack technique
+//!
+//! - **Frontend** : Vue.js 3 avec Composition API
+//! - **Langage** : TypeScript
+//! - **Build** : Vite (rapide, moderne, HMR)
+//! - **Routing** : Vue Router
+//! - **Markdown** : Marked.js pour le rendu
+//! - **Sécurité** : DOMPurify pour la sanitization HTML
+//!
+//! ### Structure des fichiers
+//!
+//! ```text
+//! pmoapp/
+//! ├── Cargo.toml              # Dépendances Rust (rust-embed)
+//! ├── src/
+//! │   └── lib.rs              # Point d'entrée Rust (ce fichier)
+//! └── webapp/
+//!     ├── src/
+//!     │   ├── main.ts         # Point d'entrée Vue.js
+//!     │   ├── App.vue         # Composant racine
+//!     │   ├── router/         # Configuration Vue Router
+//!     │   └── components/
+//!     │       ├── LogView.vue # Visualiseur de logs SSE
+//!     │       └── ...
+//!     ├── dist/               # Build output (généré, non versionné)
+//!     ├── package.json        # Dépendances npm
+//!     └── vite.config.ts      # Configuration Vite
+//! ```
+//!
+//! ## Workflow de build
+//!
+//! ### 1. Build de la webapp (Vue.js)
+//!
+//! ```bash
+//! # Installation des dépendances
+//! cd pmoapp/webapp
+//! npm install
+//!
+//! # Build de production
+//! npm run build
+//! # Génère : webapp/dist/index.html, assets/*.js, assets/*.css
+//! ```
+//!
+//! ### 2. Compilation Rust
+//!
+//! ```bash
+//! cargo build
+//! # RustEmbed inclut automatiquement les fichiers de webapp/dist/
+//! ```
+//!
+//! ### 3. Utilisation avec Makefile
+//!
+//! ```bash
+//! # Build complet (webapp + Rust)
+//! make build
+//!
+//! # Ou juste la webapp
+//! make webapp
+//!
+//! # Clean
+//! make clean
+//! ```
 //!
 //! ## Utilisation
 //!
-//! ```rust,no_run
+//! ### Exemple basique
+//!
+//! ```rust,ignore
 //! use pmoapp::Webapp;
 //! use pmoserver::ServerBuilder;
 //!
-//! # async fn example() {
-//! let mut server = ServerBuilder::new("MyApp").build();
-//! server.add_spa::<Webapp>("/app").await;
-//! # }
+//! #[tokio::main]
+//! async fn main() {
+//!     let mut server = ServerBuilder::new("MyApp", "http://localhost", 8080)
+//!         .build();
+//!
+//!     // Ajouter la webapp comme Single Page Application
+//!     server.add_spa::<Webapp>("/app").await;
+//!
+//!     // Ajouter une redirection de la racine vers /app
+//!     server.add_redirect("/", "/app").await;
+//!
+//!     server.start().await;
+//!     server.wait().await;
+//! }
 //! ```
 //!
-//! ## Structure
+//! ### Exemple avec logs SSE
 //!
-//! La webapp est construite avec Vite et Vue.js, et les fichiers statiques
-//! sont embarqués dans le binaire au moment de la compilation via `RustEmbed`.
+//! ```rust,ignore
+//! use pmoapp::Webapp;
+//! use pmoserver::{ServerBuilder, logs::{LogState, SseLayer}};
+//! use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!     // Configuration des logs avec SSE
+//!     let log_state = LogState::new(1000); // Buffer de 1000 logs
+//!     tracing_subscriber::registry()
+//!         .with(tracing_subscriber::fmt::layer())
+//!         .with(SseLayer::new(log_state.clone()))
+//!         .init();
+//!
+//!     let mut server = ServerBuilder::new("MyApp", "http://localhost", 8080).build();
+//!
+//!     // Endpoints SSE pour les logs
+//!     server.add_handler_with_state("/log-sse", pmoserver::logs::log_sse, log_state.clone()).await;
+//!     server.add_handler_with_state("/log-dump", pmoserver::logs::log_dump, log_state).await;
+//!
+//!     // Webapp (consommera les logs via /log-sse)
+//!     server.add_spa::<Webapp>("/app").await;
+//!     server.add_redirect("/", "/app").await;
+//!
+//!     server.start().await;
+//!     server.wait().await;
+//! }
+//! ```
+//!
+//! ## Développement
+//!
+//! ### Mode développement Vue.js
+//!
+//! Pour développer la webapp avec Hot Module Replacement :
+//!
+//! ```bash
+//! cd pmoapp/webapp
+//! npm run dev
+//! # Serveur de dev sur http://localhost:5173
+//! ```
+//!
+//! ### Rebuild après modifications
+//!
+//! Après avoir modifié le code Vue.js :
+//!
+//! ```bash
+//! # Rebuild webapp + recompile Rust
+//! make build
+//!
+//! # Ou séparément
+//! make webapp        # Build Vue.js seulement
+//! cargo build        # Recompile Rust (intègre le nouveau dist/)
+//! ```
+//!
+//! ## Composants Vue.js
+//!
+//! ### LogView
+//!
+//! Composant principal pour la visualisation des logs :
+//!
+//! - **Connexion SSE** : Stream temps réel via EventSource
+//! - **Filtrage** : Par niveau (TRACE, DEBUG, INFO, WARN, ERROR)
+//! - **Auto-scroll** : Activable/désactivable
+//! - **Formatage** : Markdown + détection XML automatique
+//! - **Buffer** : Limite à 1000 logs en mémoire
+//! - **Déduplication** : Évite les logs en double
+//!
+//! ### Formatage XML
+//!
+//! Le composant LogView détecte automatiquement le XML dans les messages :
+//!
+//! ```text
+//! Input:  "INFO: <?xml version=\"1.0\"?><scpd>...</scpd>"
+//! Output: Bloc de code avec coloration syntaxique XML
+//! ```
+//!
+//! - Détection via regex : `<?xml` ou balises courantes (`<scpd>`, `<service>`, etc.)
+//! - Conversion en bloc markdown : ` ```xml ... ``` `
+//! - Rendu avec coloration et scrollbar pour le XML long
+//!
+//! ## Intégration avec pmoupnp
+//!
+//! La webapp communique avec les devices UPnP via les endpoints HTTP fournis par
+//! `pmoserver` et `pmoupnp` :
+//!
+//! - `/log-sse` : Stream de logs (Server-Sent Events)
+//! - `/log-dump` : Historique des logs
+//! - `/device/*/description.xml` : Descripteurs UPnP
+//! - `/service/*/control` : Endpoints de contrôle SOAP
+//! - `/service/*/event` : Souscription aux événements UPnP
+//!
+//! ## Notes de déploiement
+//!
+//! ### Taille du binaire
+//!
+//! La webapp ajoutera ~150KB au binaire (compressé avec gzip par RustEmbed).
+//!
+//! ### Cache du navigateur
+//!
+//! Les assets sont servis avec des hashes dans les noms de fichiers
+//! (`index-BBZcSinC.js`) pour un cache busting automatique.
+//!
+//! ### Compatibilité navigateurs
+//!
+//! - Chrome/Edge : ✅ Moderne
+//! - Firefox : ✅ Moderne
+//! - Safari : ✅ iOS 13+
+//! - IE11 : ❌ Non supporté (utilise ES modules)
+//!
+//! ## Voir aussi
+//!
+//! - [`pmoserver`] : Serveur HTTP Axum pour servir la webapp
+//! - [`pmoupnp`] : Bibliothèque UPnP MediaRenderer
+//! - [Vue.js Documentation](https://vuejs.org/)
+//! - [Vite Documentation](https://vitejs.dev/)
 
 use rust_embed::RustEmbed;
 
@@ -35,17 +246,73 @@ use rust_embed::RustEmbed;
 ///
 /// ## Exemple
 ///
-/// ```rust,no_run
-/// use pmoapp::Webapp;
+/// ```rust,ignore
+/// use pmoapp::{Webapp, WebAppExt};
 /// use pmoserver::ServerBuilder;
 ///
 /// # async fn example() {
-/// let mut server = ServerBuilder::new("MyApp").build();
+/// let mut server = ServerBuilder::new("MyApp", "http://localhost", 8080).build();
 ///
-/// // Ajouter la webapp comme SPA sur le chemin /app
-/// server.add_spa::<Webapp>("/app").await;
+/// // Ajouter la webapp via le trait WebAppExt
+/// server.add_webapp::<Webapp>("/app").await;
 /// # }
 /// ```
 #[derive(RustEmbed, Clone)]
 #[folder = "webapp/dist"]
 pub struct Webapp;
+
+/// Trait pour étendre un serveur HTTP avec des fonctionnalités webapp.
+///
+/// Ce trait permet à `pmoapp` d'ajouter des méthodes d'extension sur des types
+/// de serveurs externes (comme `pmoserver::Server`) sans que ces crates dépendent de `pmoapp`.
+///
+/// # Architecture
+///
+/// Similaire au pattern utilisé par `pmoupnp` pour `UpnpServer`, ce trait permet
+/// une extension propre et découplée :
+///
+/// - `pmoserver` définit un serveur HTTP générique
+/// - `pmoapp` étend ce serveur avec des méthodes webapp via ce trait
+/// - Le serveur n'a pas besoin de connaître `pmoapp`
+///
+/// # Exemple d'implémentation
+///
+/// ```ignore
+/// impl WebAppExt for pmoserver::Server {
+///     fn add_webapp<W: RustEmbed>(&mut self, path: &str) -> ... {
+///         // Délègue à la méthode interne add_spa
+///         self.add_spa::<W>(path)
+///     }
+/// }
+/// ```
+pub trait WebAppExt {
+    /// Ajoute une Single Page Application au serveur.
+    ///
+    /// # Arguments
+    ///
+    /// * `path` - Le chemin où monter la webapp (ex: "/app")
+    ///
+    /// # Type Parameter
+    ///
+    /// * `W` - Type RustEmbed contenant les fichiers de la webapp
+    async fn add_webapp<W>(&mut self, path: &str)
+    where
+        W: RustEmbed + Clone + Send + Sync + 'static;
+
+    /// Ajoute une webapp avec une redirection automatique depuis la racine.
+    ///
+    /// # Arguments
+    ///
+    /// * `path` - Le chemin où monter la webapp (ex: "/app")
+    ///
+    /// # Type Parameter
+    ///
+    /// * `W` - Type RustEmbed contenant les fichiers de la webapp
+    async fn add_webapp_with_redirect<W>(&mut self, path: &str)
+    where
+        W: RustEmbed + Clone + Send + Sync + 'static;
+}
+
+// Implémentation du trait pour pmoserver::Server (feature-gated)
+#[cfg(feature = "pmoserver")]
+mod pmoserver_impl;

pmoapp/src/pmoserver_impl.rs

@@ -0,0 +1,79 @@
+//! Implémentation du trait WebAppExt pour le serveur pmoserver
+//!
+//! Ce module enrichit `pmoserver::Server` avec les fonctionnalités webapp en
+//! implémentant le trait [`WebAppExt`](crate::WebAppExt). Cette implémentation
+//! permet d'enregistrer facilement des webapps embarquées sur le serveur.
+//!
+//! ## Architecture
+//!
+//! `pmoapp` étend `pmoserver::Server` sans que `pmoserver` connaisse `pmoapp`.
+//! C'est le pattern d'extension : `pmoapp` ajoute des fonctionnalités à un type
+//! externe via un trait, similaire au pattern utilisé par `pmoupnp` pour `UpnpServer`.
+//!
+//! ## Exemple d'utilisation
+//!
+//! ```rust,ignore
+//! use pmoapp::{Webapp, WebAppExt};
+//! use pmoserver::ServerBuilder;
+//!
+//! # async fn example() {
+//! let mut server = ServerBuilder::new("MyApp", "http://localhost", 8080).build();
+//!
+//! // Le trait WebAppExt est automatiquement disponible
+//! server.add_webapp::<Webapp>("/app").await;
+//!
+//! // Ou avec redirection
+//! server.add_webapp_with_redirect::<Webapp>("/app").await;
+//! # }
+//! ```
+
+use crate::WebAppExt;
+use pmoserver::Server;
+use rust_embed::RustEmbed;
+
+impl WebAppExt for Server {
+    async fn add_webapp<W>(&mut self, path: &str)
+    where
+        W: RustEmbed + Clone + Send + Sync + 'static,
+    {
+        let mount_path = normalize_mount_path(path);
+        mount_spa_with_trailing_slash_redirect::<W>(self, &mount_path).await;
+    }
+
+    async fn add_webapp_with_redirect<W>(&mut self, path: &str)
+    where
+        W: RustEmbed + Clone + Send + Sync + 'static,
+    {
+        let mount_path = normalize_mount_path(path);
+
+        mount_spa_with_trailing_slash_redirect::<W>(self, &mount_path).await;
+        self.add_redirect("/", &mount_path).await;
+    }
+}
+
+/// S'assure que les chemins SPA sont cohérents : `"/app"` devient `"/app"`,
+/// tandis que `"/"` reste tel quel. Les espaces ou slashs multiples sont
+/// nettoyés pour éviter des routes dupliquées.
+fn normalize_mount_path(path: &str) -> String {
+    let trimmed = path.trim();
+
+    if trimmed.is_empty() || trimmed == "/" {
+        "/".to_string()
+    } else {
+        format!("/{}", trimmed.trim_matches('/'))
+    }
+}
+
+/// Monte la SPA et ajoute automatiquement une redirection `"/app/" -> "/app"`
+/// afin que les URLs avec slash final servent également l'application.
+async fn mount_spa_with_trailing_slash_redirect<W>(server: &mut Server, path: &str)
+where
+    W: RustEmbed + Clone + Send + Sync + 'static,
+{
+    server.add_spa::<W>(path).await;
+
+    if path != "/" {
+        let trailing = format!("{}/", path.trim_end_matches('/'));
+        server.add_redirect(&trailing, path).await;
+    }
+}

pmoapp/webapp/dist/index.html

@@ -1,14 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/app/vite.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>webapp</title>
-    <script type="module" crossorigin src="/app/assets/index-dpjDzo83.js"></script>
-    <link rel="stylesheet" crossorigin href="/app/assets/index-C_vitQ9d.css">
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

pmoapp/webapp/dist/vite.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

pmoapp/webapp/node_modules/.bin/esbuild

@@ -1 +0,0 @@
-../esbuild/bin/esbuild

pmoapp/webapp/node_modules/.bin/marked

@@ -1 +0,0 @@
-../marked/bin/marked.js

pmoapp/webapp/node_modules/.bin/nanoid

@@ -1 +0,0 @@
-../nanoid/bin/nanoid.cjs

pmoapp/webapp/node_modules/.bin/parser

@@ -1 +0,0 @@
-../@babel/parser/bin/babel-parser.js

pmoapp/webapp/node_modules/.bin/rollup

@@ -1 +0,0 @@
-../rollup/dist/bin/rollup

pmoapp/webapp/node_modules/.bin/tsc

@@ -1 +0,0 @@
-../typescript/bin/tsc

pmoapp/webapp/node_modules/.bin/tsserver

@@ -1 +0,0 @@
-../typescript/bin/tsserver

pmoapp/webapp/node_modules/.bin/vite

@@ -1 +0,0 @@
-../vite/bin/vite.js

pmoapp/webapp/node_modules/.bin/vue-tsc

@@ -1 +0,0 @@
-../vue-tsc/bin/vue-tsc.js

pmoapp/webapp/node_modules/.tmp/tsconfig.app.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../../src/main.ts","../../src/shims-vue.d.ts","../../src/router/index.ts","../../src/app.vue","../../src/components/helloworld.vue","../../src/components/logview.vue"],"version":"5.8.3"}

pmoapp/webapp/node_modules/.tmp/tsconfig.node.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../../vite.config.ts"],"version":"5.8.3"}

pmoapp/webapp/node_modules/.vue-global-types/vue_3.5_0.d.ts

@@ -1,137 +0,0 @@
-// @ts-nocheck
-export {};
-
-; declare global {
-	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
-	const __VLS_unref: typeof import('vue').unref;
-	const __VLS_placeholder: any;
-
-	type __VLS_NativeElements = __VLS_SpreadMerge<SVGElementTagNameMap, HTMLElementTagNameMap>;
-	type __VLS_IntrinsicElements = import('vue/jsx-runtime').JSX.IntrinsicElements;
-	type __VLS_Element = import('vue/jsx-runtime').JSX.Element;
-	type __VLS_GlobalComponents = import('vue').GlobalComponents;
-	type __VLS_GlobalDirectives = import('vue').GlobalDirectives;
-	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
-	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
-	type __VLS_SpreadMerge<A, B> = Omit<A, keyof B> & B;
-	type __VLS_WithComponent<N0 extends string, LocalComponents, Self, N1 extends string, N2 extends string, N3 extends string> =
-		N1 extends keyof LocalComponents ? { [K in N0]: LocalComponents[N1] } :
-		N2 extends keyof LocalComponents ? { [K in N0]: LocalComponents[N2] } :
-		N3 extends keyof LocalComponents ? { [K in N0]: LocalComponents[N3] } :
-		Self extends object ? { [K in N0]: Self } :
-		N1 extends keyof __VLS_GlobalComponents ? { [K in N0]: __VLS_GlobalComponents[N1] } :
-		N2 extends keyof __VLS_GlobalComponents ? { [K in N0]: __VLS_GlobalComponents[N2] } :
-		N3 extends keyof __VLS_GlobalComponents ? { [K in N0]: __VLS_GlobalComponents[N3] } :
-		{};
-	type __VLS_FunctionalComponentCtx<T, K> = __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}>
-		? K extends { __ctx?: infer Ctx } ? NonNullable<Ctx> : never : any
-		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
-	>;
-	type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}>
-		? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
-		: T extends (props: infer P, ...args: any) => any ? P
-		: {};
-	type __VLS_FunctionalComponent<T> = (props: (T extends { $props: infer Props } ? Props : {}) & Record<string, unknown>, ctx?: any) => __VLS_Element & {
-		__ctx?: {
-			attrs?: any;
-			slots?: T extends { $slots: infer Slots } ? Slots : Record<string, any>;
-			emit?: T extends { $emit: infer Emit } ? Emit : {};
-			props?: (T extends { $props: infer Props } ? Props : {}) & Record<string, unknown>;
-			expose?: (exposed: T) => void;
-		};
-	};
-	type __VLS_IsFunction<T, K> = K extends keyof T
-		? __VLS_IsAny<T[K]> extends false
-		? unknown extends T[K]
-		? false
-		: true
-		: false
-		: false;
-	type __VLS_NormalizeComponentEvent<
-		Props,
-		Emits,
-		onEvent extends keyof Props,
-		Event extends keyof Emits,
-		CamelizedEvent extends keyof Emits,
-	> = __VLS_IsFunction<Props, onEvent> extends true
-		? Props
-		: __VLS_IsFunction<Emits, Event> extends true
-			? { [K in onEvent]?: Emits[Event] }
-			: __VLS_IsFunction<Emits, CamelizedEvent> extends true
-				? { [K in onEvent]?: Emits[CamelizedEvent] }
-				: Props;
-	// fix https://github.com/vuejs/language-tools/issues/926
-	type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
-	type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R
-		? U extends T
-		? never
-		: __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R)
-		: never;
-	type __VLS_OverloadUnion<T> = Exclude<
-		__VLS_OverloadUnionInner<(() => never) & T>,
-		T extends () => never ? never : () => never
-	>;
-	type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F
-		? F extends (event: infer E, ...args: infer A) => any
-		? { [K in E & string]: (...args: A) => void; }
-		: never
-		: never;
-	type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
-		__VLS_UnionToIntersection<
-			__VLS_ConstructorOverloads<T> & {
-				[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
-			}
-		>
-	>;
-	type __VLS_EmitsToProps<T> = __VLS_PrettifyGlobal<{
-		[K in string & keyof T as `on${Capitalize<K>}`]?:
-			(...args: T[K] extends (...args: infer P) => any ? P : T[K] extends null ? any[] : never) => any;
-	}>;
-	type __VLS_ResolveEmits<
-		Comp,
-		Emits,
-		TypeEmits = {},
-		NormalizedEmits = __VLS_NormalizeEmits<Emits> extends infer E ? string extends keyof E ? {} : E : never,
-	> = __VLS_SpreadMerge<NormalizedEmits, TypeEmits>;
-	type __VLS_ResolveDirectives<T> = {
-		[K in keyof T & string as `v${Capitalize<K>}`]: T[K];
-	};
-	type __VLS_PrettifyGlobal<T> = { [K in keyof T as K]: T[K]; } & {};
-	type __VLS_WithDefaultsGlobal<P, D> = {
-		[K in keyof P as K extends keyof D ? K : never]-?: P[K];
-	} & {
-		[K in keyof P as K extends keyof D ? never : K]: P[K];
-	};
-	type __VLS_UseTemplateRef<T> = Readonly<import('vue').ShallowRef<T | null>>;
-	type __VLS_ProxyRefs<T> = import('vue').ShallowUnwrapRef<T>;
-
-	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [
-		item: T extends number ? number
-			: T extends string ? string
-			: T extends any[] ? T[number]
-			: T extends Iterable<infer T1> ? T1
-			: any,
-		index: number,
-	][];
-	function __VLS_getVForSourceType<T>(source: T): [
-		item: T[keyof T],
-		key: keyof T,
-		index: number,
-	][];
-	function __VLS_getSlotParameters<S, D extends S>(slot: S, decl?: D):
-		D extends (...args: infer P) => any ? P : any[];
-	function __VLS_asFunctionalDirective<T>(dir: T): T extends import('vue').ObjectDirective
-		? NonNullable<T['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>
-		: T extends (...args: any) => any
-			? T
-			: (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
-	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
-		T extends new (...args: any) => any ? __VLS_FunctionalComponent<K>
-		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
-		: T extends (...args: any) => any ? T
-		: __VLS_FunctionalComponent<{}>;
-	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
-	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T & Record<string, unknown>) => void;
-	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;
-	function __VLS_tryAsConstant<const T>(t: T): T;
-}

pmoapp/webapp/node_modules/@babel/helper-string-parser/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pmoapp/webapp/node_modules/@babel/helper-string-parser/README.md

@@ -1,19 +0,0 @@
-# @babel/helper-string-parser
-
-> A utility package to parse strings
-
-See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save @babel/helper-string-parser
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/helper-string-parser
-```

pmoapp/webapp/node_modules/@babel/helper-string-parser/lib/index.js

@@ -1,295 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.readCodePoint = readCodePoint;
-exports.readInt = readInt;
-exports.readStringContents = readStringContents;
-var _isDigit = function isDigit(code) {
-  return code >= 48 && code <= 57;
-};
-const forbiddenNumericSeparatorSiblings = {
-  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
-  hex: new Set([46, 88, 95, 120])
-};
-const isAllowedNumericSeparatorSibling = {
-  bin: ch => ch === 48 || ch === 49,
-  oct: ch => ch >= 48 && ch <= 55,
-  dec: ch => ch >= 48 && ch <= 57,
-  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
-};
-function readStringContents(type, input, pos, lineStart, curLine, errors) {
-  const initialPos = pos;
-  const initialLineStart = lineStart;
-  const initialCurLine = curLine;
-  let out = "";
-  let firstInvalidLoc = null;
-  let chunkStart = pos;
-  const {
-    length
-  } = input;
-  for (;;) {
-    if (pos >= length) {
-      errors.unterminated(initialPos, initialLineStart, initialCurLine);
-      out += input.slice(chunkStart, pos);
-      break;
-    }
-    const ch = input.charCodeAt(pos);
-    if (isStringEnd(type, ch, input, pos)) {
-      out += input.slice(chunkStart, pos);
-      break;
-    }
-    if (ch === 92) {
-      out += input.slice(chunkStart, pos);
-      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
-      if (res.ch === null && !firstInvalidLoc) {
-        firstInvalidLoc = {
-          pos,
-          lineStart,
-          curLine
-        };
-      } else {
-        out += res.ch;
-      }
-      ({
-        pos,
-        lineStart,
-        curLine
-      } = res);
-      chunkStart = pos;
-    } else if (ch === 8232 || ch === 8233) {
-      ++pos;
-      ++curLine;
-      lineStart = pos;
-    } else if (ch === 10 || ch === 13) {
-      if (type === "template") {
-        out += input.slice(chunkStart, pos) + "\n";
-        ++pos;
-        if (ch === 13 && input.charCodeAt(pos) === 10) {
-          ++pos;
-        }
-        ++curLine;
-        chunkStart = lineStart = pos;
-      } else {
-        errors.unterminated(initialPos, initialLineStart, initialCurLine);
-      }
-    } else {
-      ++pos;
-    }
-  }
-  return {
-    pos,
-    str: out,
-    firstInvalidLoc,
-    lineStart,
-    curLine,
-    containsInvalid: !!firstInvalidLoc
-  };
-}
-function isStringEnd(type, ch, input, pos) {
-  if (type === "template") {
-    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
-  }
-  return ch === (type === "double" ? 34 : 39);
-}
-function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
-  const throwOnInvalid = !inTemplate;
-  pos++;
-  const res = ch => ({
-    pos,
-    ch,
-    lineStart,
-    curLine
-  });
-  const ch = input.charCodeAt(pos++);
-  switch (ch) {
-    case 110:
-      return res("\n");
-    case 114:
-      return res("\r");
-    case 120:
-      {
-        let code;
-        ({
-          code,
-          pos
-        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
-        return res(code === null ? null : String.fromCharCode(code));
-      }
-    case 117:
-      {
-        let code;
-        ({
-          code,
-          pos
-        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
-        return res(code === null ? null : String.fromCodePoint(code));
-      }
-    case 116:
-      return res("\t");
-    case 98:
-      return res("\b");
-    case 118:
-      return res("\u000b");
-    case 102:
-      return res("\f");
-    case 13:
-      if (input.charCodeAt(pos) === 10) {
-        ++pos;
-      }
-    case 10:
-      lineStart = pos;
-      ++curLine;
-    case 8232:
-    case 8233:
-      return res("");
-    case 56:
-    case 57:
-      if (inTemplate) {
-        return res(null);
-      } else {
-        errors.strictNumericEscape(pos - 1, lineStart, curLine);
-      }
-    default:
-      if (ch >= 48 && ch <= 55) {
-        const startPos = pos - 1;
-        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
-        let octalStr = match[0];
-        let octal = parseInt(octalStr, 8);
-        if (octal > 255) {
-          octalStr = octalStr.slice(0, -1);
-          octal = parseInt(octalStr, 8);
-        }
-        pos += octalStr.length - 1;
-        const next = input.charCodeAt(pos);
-        if (octalStr !== "0" || next === 56 || next === 57) {
-          if (inTemplate) {
-            return res(null);
-          } else {
-            errors.strictNumericEscape(startPos, lineStart, curLine);
-          }
-        }
-        return res(String.fromCharCode(octal));
-      }
-      return res(String.fromCharCode(ch));
-  }
-}
-function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
-  const initialPos = pos;
-  let n;
-  ({
-    n,
-    pos
-  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
-  if (n === null) {
-    if (throwOnInvalid) {
-      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
-    } else {
-      pos = initialPos - 1;
-    }
-  }
-  return {
-    code: n,
-    pos
-  };
-}
-function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
-  const start = pos;
-  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
-  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
-  let invalid = false;
-  let total = 0;
-  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-    const code = input.charCodeAt(pos);
-    let val;
-    if (code === 95 && allowNumSeparator !== "bail") {
-      const prev = input.charCodeAt(pos - 1);
-      const next = input.charCodeAt(pos + 1);
-      if (!allowNumSeparator) {
-        if (bailOnError) return {
-          n: null,
-          pos
-        };
-        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
-        if (bailOnError) return {
-          n: null,
-          pos
-        };
-        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
-      }
-      ++pos;
-      continue;
-    }
-    if (code >= 97) {
-      val = code - 97 + 10;
-    } else if (code >= 65) {
-      val = code - 65 + 10;
-    } else if (_isDigit(code)) {
-      val = code - 48;
-    } else {
-      val = Infinity;
-    }
-    if (val >= radix) {
-      if (val <= 9 && bailOnError) {
-        return {
-          n: null,
-          pos
-        };
-      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
-        val = 0;
-      } else if (forceLen) {
-        val = 0;
-        invalid = true;
-      } else {
-        break;
-      }
-    }
-    ++pos;
-    total = total * radix + val;
-  }
-  if (pos === start || len != null && pos - start !== len || invalid) {
-    return {
-      n: null,
-      pos
-    };
-  }
-  return {
-    n: total,
-    pos
-  };
-}
-function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
-  const ch = input.charCodeAt(pos);
-  let code;
-  if (ch === 123) {
-    ++pos;
-    ({
-      code,
-      pos
-    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
-    ++pos;
-    if (code !== null && code > 0x10ffff) {
-      if (throwOnInvalid) {
-        errors.invalidCodePoint(pos, lineStart, curLine);
-      } else {
-        return {
-          code: null,
-          pos
-        };
-      }
-    }
-  } else {
-    ({
-      code,
-      pos
-    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
-  }
-  return {
-    code,
-    pos
-  };
-}
-
-//# sourceMappingURL=index.js.map

pmoapp/webapp/node_modules/@babel/helper-string-parser/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "@babel/helper-string-parser",
-  "version": "7.27.1",
-  "description": "A utility package to parse strings",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-helper-string-parser"
-  },
-  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./lib/index.js",
-  "devDependencies": {
-    "charcodes": "^0.2.0"
-  },
-  "engines": {
-    "node": ">=6.9.0"
-  },
-  "author": "The Babel Team (https://babel.dev/team)",
-  "exports": {
-    ".": {
-      "types": "./lib/index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "type": "commonjs"
-}

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/README.md

@@ -1,19 +0,0 @@
-# @babel/helper-validator-identifier
-
-> Validate identifier/keywords name
-
-See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save @babel/helper-validator-identifier
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/helper-validator-identifier
-```

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/lib/identifier.js

@@ -1,70 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isIdentifierChar = isIdentifierChar;
-exports.isIdentifierName = isIdentifierName;
-exports.isIdentifierStart = isIdentifierStart;
-let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
-const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
-function isInAstralSet(code, set) {
-  let pos = 0x10000;
-  for (let i = 0, length = set.length; i < length; i += 2) {
-    pos += set[i];
-    if (pos > code) return false;
-    pos += set[i + 1];
-    if (pos >= code) return true;
-  }
-  return false;
-}
-function isIdentifierStart(code) {
-  if (code < 65) return code === 36;
-  if (code <= 90) return true;
-  if (code < 97) return code === 95;
-  if (code <= 122) return true;
-  if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  }
-  return isInAstralSet(code, astralIdentifierStartCodes);
-}
-function isIdentifierChar(code) {
-  if (code < 48) return code === 36;
-  if (code < 58) return true;
-  if (code < 65) return false;
-  if (code <= 90) return true;
-  if (code < 97) return code === 95;
-  if (code <= 122) return true;
-  if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  }
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
-}
-function isIdentifierName(name) {
-  let isFirst = true;
-  for (let i = 0; i < name.length; i++) {
-    let cp = name.charCodeAt(i);
-    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
-      const trail = name.charCodeAt(++i);
-      if ((trail & 0xfc00) === 0xdc00) {
-        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
-      }
-    }
-    if (isFirst) {
-      isFirst = false;
-      if (!isIdentifierStart(cp)) {
-        return false;
-      }
-    } else if (!isIdentifierChar(cp)) {
-      return false;
-    }
-  }
-  return !isFirst;
-}
-
-//# sourceMappingURL=identifier.js.map

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/lib/index.js

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "isIdentifierChar", {
-  enumerable: true,
-  get: function () {
-    return _identifier.isIdentifierChar;
-  }
-});
-Object.defineProperty(exports, "isIdentifierName", {
-  enumerable: true,
-  get: function () {
-    return _identifier.isIdentifierName;
-  }
-});
-Object.defineProperty(exports, "isIdentifierStart", {
-  enumerable: true,
-  get: function () {
-    return _identifier.isIdentifierStart;
-  }
-});
-Object.defineProperty(exports, "isKeyword", {
-  enumerable: true,
-  get: function () {
-    return _keyword.isKeyword;
-  }
-});
-Object.defineProperty(exports, "isReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _keyword.isReservedWord;
-  }
-});
-Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _keyword.isStrictBindOnlyReservedWord;
-  }
-});
-Object.defineProperty(exports, "isStrictBindReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _keyword.isStrictBindReservedWord;
-  }
-});
-Object.defineProperty(exports, "isStrictReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _keyword.isStrictReservedWord;
-  }
-});
-var _identifier = require("./identifier.js");
-var _keyword = require("./keyword.js");
-
-//# sourceMappingURL=index.js.map

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  isIdentifierName,\n  isIdentifierChar,\n  isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/lib/keyword.js

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isKeyword = isKeyword;
-exports.isReservedWord = isReservedWord;
-exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
-exports.isStrictBindReservedWord = isStrictBindReservedWord;
-exports.isStrictReservedWord = isStrictReservedWord;
-const reservedWords = {
-  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
-  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
-  strictBind: ["eval", "arguments"]
-};
-const keywords = new Set(reservedWords.keyword);
-const reservedWordsStrictSet = new Set(reservedWords.strict);
-const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
-function isReservedWord(word, inModule) {
-  return inModule && word === "await" || word === "enum";
-}
-function isStrictReservedWord(word, inModule) {
-  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
-}
-function isStrictBindOnlyReservedWord(word) {
-  return reservedWordsStrictBindSet.has(word);
-}
-function isStrictBindReservedWord(word, inModule) {
-  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
-}
-function isKeyword(word) {
-  return keywords.has(word);
-}
-
-//# sourceMappingURL=keyword.js.map

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}

pmoapp/webapp/node_modules/@babel/helper-validator-identifier/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "@babel/helper-validator-identifier",
-  "version": "7.27.1",
-  "description": "Validate identifier/keywords name",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-helper-validator-identifier"
-  },
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./lib/index.js",
-  "exports": {
-    ".": {
-      "types": "./lib/index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "devDependencies": {
-    "@unicode/unicode-16.0.0": "^1.0.0",
-    "charcodes": "^0.2.0"
-  },
-  "engines": {
-    "node": ">=6.9.0"
-  },
-  "author": "The Babel Team (https://babel.dev/team)",
-  "type": "commonjs"
-}

pmoapp/webapp/node_modules/@babel/parser/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2012-2014 by various contributors (see AUTHORS)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

pmoapp/webapp/node_modules/@babel/parser/README.md

@@ -1,19 +0,0 @@
-# @babel/parser
-
-> A JavaScript parser
-
-See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/parser
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/parser --dev
-```