From 82fe72d6593d34c1992a8d633a6ee5c970d0b5eb Mon Sep 17 00:00:00 2001
From: Eric Coissac <eric@coissac.eu>
Date: Sun, 19 Oct 2025 13:42:29 +0200
Subject: [PATCH] =?UTF-8?q?am=C3=A9lioration=20de=20la=20webapp?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .pmomusic_audio/cache.db                      | Bin 20480 -> 20480 bytes
 PMOMusic/src/main.rs                          |   2 +-
 pmoapp/src/lib.rs                             |   4 +-
 .../src/components/RadioParadiseExplorer.vue  | 129 +++++++++-
 pmoapp/webapp/src/components/UpnpExplorer.vue |  83 ++++++-
 .../src/components/upnp/ActionsList.vue       |  36 +++
 pmoaudio/examples/multiroom_demo.rs           |   5 +-
 pmoaudio/examples/multiroom_volume_demo.rs    |  13 +-
 pmoaudio/examples/quick_start.rs              |   8 +-
 pmoaudio/src/audio_chunk.rs                   |   8 +-
 pmoaudio/src/lib.rs                           |   6 +-
 pmoaudio/src/nodes/buffer_node.rs             |   5 +-
 pmoaudio/src/nodes/chromecast_sink.rs         |   5 +-
 pmoaudio/src/nodes/decoder_node.rs            |  16 +-
 pmoaudio/src/nodes/disk_sink.rs               |  77 +++---
 pmoaudio/src/nodes/dsp_node.rs                |  20 +-
 pmoaudio/src/nodes/mod.rs                     |   5 +-
 pmoaudio/src/nodes/mpd_sink.rs                |   4 +-
 pmoaudio/src/nodes/sink_node.rs               |   8 +-
 pmoaudio/src/nodes/source_node.rs             |  13 +-
 pmoaudio/src/nodes/timer_node.rs              |   5 +-
 pmoaudio/tests/integration_test.rs            |  15 +-
 pmoaudiocache/examples/test_flac_debug.rs     |  14 +-
 pmoaudiocache/src/cache.rs                    |  75 +++---
 pmoaudiocache/src/flac.rs                     |   9 +-
 pmoaudiocache/src/lib.rs                      |  20 +-
 pmoaudiocache/src/metadata.rs                 |  12 +-
 pmocache/examples/simple_transformer.rs       |   4 +-
 .../examples/test_download_transformer.rs     |  31 ++-
 pmocache/src/api.rs                           |  13 +-
 pmocache/src/cache.rs                         |  46 ++--
 pmocache/src/db.rs                            | 107 +++++----
 pmocache/src/download.rs                      |  61 +++--
 pmocache/src/lib.rs                           |  15 +-
 pmocache/src/pmoserver_ext.rs                 |  46 ++--
 pmocovers/src/cache.rs                        |   8 +-
 pmocovers/src/lib.rs                          |  38 +--
 pmocovers/src/webp.rs                         |  27 +--
 pmodidl/src/lib.rs                            | 220 ++++++++++--------
 .../src/avtransport/actions/getmediainfo.rs   |   5 +-
 .../avtransport/actions/getpositioninfo.rs    |   5 +-
 .../src/avtransport/actions/mod.rs            |   1 -
 .../src/avtransport/actions/play.rs           |   2 +-
 .../src/avtransport/actions/seek.rs           |   4 +-
 .../actions/setavtransportnexturi.rs          |   4 +-
 .../avtransport/actions/setavtransporturi.rs  |   4 +-
 pmomediarenderer/src/avtransport/mod.rs       |  23 +-
 .../variables/avtransporturimetadata.rs       |  34 +--
 .../src/avtransport/variables/mod.rs          |   7 +-
 .../variables/possiblerecordstoragemedia.rs   |  14 +-
 .../variables/recordstoragemedium.rs          |   2 +-
 .../src/avtransport/variables/seekmode.rs     |   1 -
 .../src/avtransport/variables/track.rs        |   1 -
 .../avtransport/variables/trackduration.rs    |   1 -
 .../variables/transportplayspeed.rs           |   1 -
 .../avtransport/variables/transportstate.rs   |   1 -
 .../actions/getcurrentconnectioninfo.rs       |   4 +-
 .../actions/getprotocolinfo.rs                |   2 +-
 .../src/connectionmanager/actions/mod.rs      |   4 +-
 pmomediarenderer/src/connectionmanager/mod.rs |   6 +-
 .../src/connectionmanager/variables/mod.rs    |  16 +-
 pmomediarenderer/src/device.rs                |  14 +-
 pmomediarenderer/src/lib.rs                   |   2 +-
 .../src/renderingcontrol/actions/getmute.rs   |   2 +-
 .../src/renderingcontrol/actions/getvolume.rs |   2 +-
 .../src/renderingcontrol/actions/mod.rs       |   8 +-
 .../src/renderingcontrol/actions/setmute.rs   |   2 +-
 .../src/renderingcontrol/actions/setvolume.rs |   2 +-
 pmomediarenderer/src/renderingcontrol/mod.rs  |   2 +-
 .../src/renderingcontrol/variables/mod.rs     |   8 +-
 .../actions/getcurrentconnectioninfo.rs       |   4 +-
 .../actions/getprotocolinfo.rs                |   2 +-
 .../src/connectionmanager/actions/mod.rs      |   4 +-
 pmomediaserver/src/connectionmanager/mod.rs   |   6 +-
 .../src/connectionmanager/variables/mod.rs    |   8 +-
 pmomediaserver/src/content_handler.rs         |  17 +-
 .../src/contentdirectory/actions/browse.rs    |   7 +-
 .../actions/getsearchcapabilities.rs          |   2 +-
 .../actions/getsortcapabilities.rs            |   2 +-
 .../actions/getsystemupdateid.rs              |   2 +-
 .../src/contentdirectory/actions/mod.rs       |   4 +-
 .../src/contentdirectory/actions/search.rs    |   7 +-
 .../src/contentdirectory/handlers.rs          |  14 +-
 pmomediaserver/src/contentdirectory/mod.rs    |  13 +-
 .../src/contentdirectory/variables/mod.rs     |  20 +-
 pmomediaserver/src/device.rs                  |  11 +-
 pmomediaserver/src/lib.rs                     |  16 +-
 pmomediaserver/src/server_ext.rs              |   7 +-
 pmomediaserver/src/source_registry.rs         |  38 ++-
 pmomediaserver/src/sources.rs                 |  27 ++-
 pmomediaserver/src/sources_api.rs             |   8 +-
 pmoparadise/examples/extract_track.rs         |  28 ++-
 pmoparadise/examples/now_playing.rs           |   8 +-
 pmoparadise/examples/show_source_image.rs     |   2 +-
 pmoparadise/examples/stream_block.rs          |  20 +-
 pmoparadise/examples/upnp_mediaserver.rs      |   5 +-
 pmoparadise/examples/with_cache.rs            |  15 +-
 pmoparadise/src/client.rs                     |  11 +-
 pmoparadise/src/lib.rs                        |   6 +-
 .../src/mediaserver/connection_manager.rs     | 119 +++++-----
 .../src/mediaserver/content_directory.rs      | 147 ++++++------
 pmoparadise/src/mediaserver/mod.rs            |   6 +-
 pmoparadise/src/mediaserver/server.rs         |  22 +-
 pmoparadise/src/models.rs                     |  10 +-
 pmoparadise/src/pmoserver_ext.rs              |  46 ++--
 pmoparadise/src/source.rs                     | 116 +++++----
 pmoparadise/src/stream.rs                     |  10 +-
 pmoparadise/src/track.rs                      |  20 +-
 pmoplaylist/examples/basic_usage.rs           |  73 +++---
 .../examples/http_server_integration.rs       |  52 +++--
 pmoplaylist/examples/radio_streaming.rs       |  47 +++-
 pmoplaylist/src/lib.rs                        |  86 ++++---
 pmoqobuz/examples/basic_usage.rs              |   5 +-
 pmoqobuz/examples/server_with_covers.rs       |   4 +-
 pmoqobuz/examples/show_source_image.rs        |   2 +-
 pmoqobuz/examples/with_cache.rs               |  22 +-
 pmoqobuz/src/api/auth.rs                      |   5 +-
 pmoqobuz/src/api/catalog.rs                   |  32 ++-
 pmoqobuz/src/api/mod.rs                       |   4 +-
 pmoqobuz/src/api/user.rs                      |  71 +++---
 pmoqobuz/src/client.rs                        |  21 +-
 pmoqobuz/src/didl.rs                          |   5 +-
 pmoqobuz/src/pmoserver_ext.rs                 |   7 +-
 pmoqobuz/src/source.rs                        |  92 +++++---
 pmoserver/src/lib.rs                          |   9 +-
 pmoserver/src/logs/mod.rs                     |  38 +--
 pmoserver/src/server.rs                       |  36 ++-
 pmosource/examples/radio_paradise.rs          |  16 +-
 pmosource/src/api.rs                          |  66 +++---
 pmosource/src/cache.rs                        |  33 ++-
 pmosource/src/lib.rs                          |  26 ++-
 pmosource/src/pmoserver_impl.rs               |   5 +-
 pmoupnp/src/actions/action_handler.rs         |   3 +-
 pmoupnp/src/actions/action_instance.rs        |  48 ++--
 pmoupnp/src/actions/action_instance_set.rs    |   8 +-
 pmoupnp/src/actions/action_methods.rs         |  22 +-
 pmoupnp/src/actions/action_set_methods.rs     |   6 +-
 pmoupnp/src/actions/arg_inst_set_methods.rs   |  13 +-
 pmoupnp/src/actions/arg_instance_methods.rs   |  40 ++--
 pmoupnp/src/actions/arg_set_methods.rs        |   7 +-
 pmoupnp/src/actions/argument_methods.rs       |   6 +-
 pmoupnp/src/actions/errors.rs                 |  10 +-
 pmoupnp/src/actions/handler_helpers.rs        |  20 +-
 pmoupnp/src/actions/macros.rs                 |   8 +-
 pmoupnp/src/actions/mod.rs                    |   4 +-
 pmoupnp/src/cache_registry.rs                 |  33 ++-
 pmoupnp/src/devices/device.rs                 |  12 +-
 pmoupnp/src/devices/device_instance.rs        |  72 ++++--
 pmoupnp/src/devices/device_methods.rs         |  38 ++-
 pmoupnp/src/devices/device_registry.rs        |  61 +++--
 pmoupnp/src/devices/mod.rs                    |   5 +-
 pmoupnp/src/lib.rs                            |  13 +-
 pmoupnp/src/object_set.rs                     |   2 +-
 pmoupnp/src/object_trait.rs                   |  34 +--
 pmoupnp/src/services/errors.rs                |  18 +-
 pmoupnp/src/services/mod.rs                   |  17 +-
 pmoupnp/src/services/service_instance.rs      |  62 +++--
 pmoupnp/src/services/service_methods.rs       |  12 +-
 pmoupnp/src/soap/builder.rs                   |   8 +-
 pmoupnp/src/soap/envelope.rs                  |   5 +-
 pmoupnp/src/soap/fault.rs                     |   8 +-
 pmoupnp/src/soap/mod.rs                       |   8 +-
 pmoupnp/src/soap/parser.rs                    |  13 +-
 pmoupnp/src/ssdp/device.rs                    |   7 +-
 pmoupnp/src/ssdp/server.rs                    |   2 +-
 .../src/state_variables/instance_methods.rs   |  34 +--
 pmoupnp/src/state_variables/mod.rs            |  14 +-
 .../state_variables/var_inst_set_methods.rs   |  15 +-
 .../src/state_variables/var_set_methods.rs    |  13 +-
 .../src/state_variables/variable_methods.rs   |  32 +--
 pmoupnp/src/state_variables/variable_trait.rs |   8 +-
 pmoupnp/src/upnp_api.rs                       |  24 +-
 pmoupnp/src/upnp_server.rs                    | 122 ++++++----
 pmoupnp/src/variable_types/reflect_impl.rs    | 143 ++++++------
 pmoupnp/src/variable_types/value_methods.rs   |  66 ++++--
 pmoupnp/src/variable_types/values_from_str.rs |   2 +-
 pmoutils/src/ip_utils.rs                      |  36 +--
 pmoutils/src/lib.rs                           |   2 +-
 pmoutils/src/process.rs                       |  11 +-
 179 files changed, 2426 insertions(+), 1685 deletions(-)

diff --git a/.pmomusic_audio/cache.db b/.pmomusic_audio/cache.db
index 81988eb0da02aa43054e070910deda238f2fdab4..1d046498389845dc335ca1576be1d1942974776d 100644
GIT binary patch
delta 73
zcmZozz}T>Wae_3X)<hX+My-tr_3~1pMg~Tvx`qb2hL$0QMpgz!Rwib8md3`G=9_=Y
Sf6^C45i-^`Ft9Q(5Cs6uG!jt&

delta 73
zcmZozz}T>Wae_3X#zYxsMvaXL_3~1}Mg~Tvx`qb2hL$0QhE~RARz^m8CWdAvhMRxN
Sf6^C45i-^`Ft9Q(5C#Crl@coe

diff --git a/PMOMusic/src/main.rs b/PMOMusic/src/main.rs
index 41f8dd54..0ab5a884 100644
--- a/PMOMusic/src/main.rs
+++ b/PMOMusic/src/main.rs
@@ -1,8 +1,8 @@
 use pmoapp::{WebAppExt, Webapp};
 use pmomediarenderer::MEDIA_RENDERER;
 use pmomediaserver::{MEDIA_SERVER, sources::SourcesExt};
-use pmosource::MusicSourceExt;
 use pmoserver::Server;
+use pmosource::MusicSourceExt;
 use pmoupnp::{UpnpServerExt, upnp_api::UpnpApiExt};
 use tracing::info;
 
diff --git a/pmoapp/src/lib.rs b/pmoapp/src/lib.rs
index d9353128..fcfe1263 100644
--- a/pmoapp/src/lib.rs
+++ b/pmoapp/src/lib.rs
@@ -297,7 +297,7 @@ pub trait WebAppExt {
     /// # Type Parameter
     ///
     /// * `W` - Type RustEmbed contenant les fichiers de la webapp
-    async fn add_webapp<W>(&mut self, path: &str) 
+    async fn add_webapp<W>(&mut self, path: &str)
     where
         W: RustEmbed + Clone + Send + Sync + 'static;
 
@@ -310,7 +310,7 @@ pub trait WebAppExt {
     /// # Type Parameter
     ///
     /// * `W` - Type RustEmbed contenant les fichiers de la webapp
-    async fn add_webapp_with_redirect<W>(&mut self, path: &str) 
+    async fn add_webapp_with_redirect<W>(&mut self, path: &str)
     where
         W: RustEmbed + Clone + Send + Sync + 'static;
 }
diff --git a/pmoapp/webapp/src/components/RadioParadiseExplorer.vue b/pmoapp/webapp/src/components/RadioParadiseExplorer.vue
index 615f6c0b..92ea8021 100644
--- a/pmoapp/webapp/src/components/RadioParadiseExplorer.vue
+++ b/pmoapp/webapp/src/components/RadioParadiseExplorer.vue
@@ -8,6 +8,13 @@
           <span v-else>🔄</span>
           Refresh
         </button>
+        <button
+          @click="togglePlayback"
+          :disabled="!nowPlaying || !nowPlaying.stream_url"
+          class="btn-play"
+        >
+          {{ isPlaying ? '⏹️ Stop' : '▶️ Play' }}
+        </button>
         <select v-model="selectedChannel" @change="changeChannel" class="channel-select">
           <option v-for="channel in channels" :key="channel.id" :value="channel.id">
             {{ channel.name }}
@@ -16,6 +23,21 @@
       </div>
     </div>
 
+    <!-- Audio Player -->
+    <div v-if="isPlaying || audioError" class="audio-player-container">
+      <audio
+        v-if="!audioError"
+        ref="audioPlayer"
+        controls
+        @ended="handleAudioEnded"
+        @error="handleAudioError"
+      ></audio>
+      <p v-if="audioError" class="audio-error">{{ audioError }}</p>
+      <button @click="stopPlayback" class="btn-stop">
+        {{ audioError ? '✕ Close' : '⏹️ Stop' }}
+      </button>
+    </div>
+
     <div v-if="error" class="error-message">
       ❌ {{ error }}
     </div>
@@ -114,7 +136,7 @@
 </template>
 
 <script setup>
-import { ref, onMounted } from 'vue'
+import { ref, onMounted, nextTick } from 'vue'
 
 const API_BASE = '/api/radioparadise'
 
@@ -123,6 +145,9 @@ const error = ref(null)
 const nowPlaying = ref(null)
 const channels = ref([])
 const selectedChannel = ref(0)
+const audioPlayer = ref(null)
+const isPlaying = ref(false)
+const audioError = ref('')
 
 // Format duration from milliseconds to MM:SS
 function formatDuration(ms) {
@@ -178,6 +203,61 @@ function changeChannel() {
   // TODO: Implement channel switching in the API
 }
 
+function playStream() {
+  if (!nowPlaying.value?.stream_url) {
+    audioError.value = 'No stream URL available'
+    return
+  }
+
+  audioError.value = ''
+  isPlaying.value = true
+
+  nextTick(() => {
+    const player = audioPlayer.value
+    if (!player) {
+      return
+    }
+    player.src = nowPlaying.value.stream_url
+    player.play().catch((e) => {
+      console.error('Failed to start playback:', e)
+      audioError.value = `Cannot play stream: ${e.message}`
+      isPlaying.value = false
+    })
+  })
+}
+
+function stopPlayback() {
+  if (audioPlayer.value) {
+    audioPlayer.value.pause()
+    audioPlayer.value.currentTime = 0
+    audioPlayer.value.src = ''
+  }
+  isPlaying.value = false
+  audioError.value = ''
+}
+
+function togglePlayback() {
+  if (isPlaying.value) {
+    stopPlayback()
+  } else {
+    playStream()
+  }
+}
+
+function handleAudioEnded() {
+  isPlaying.value = false
+}
+
+function handleAudioError() {
+  const audio = audioPlayer.value
+  if (audio?.error) {
+    audioError.value = `Audio playback error (code ${audio.error.code})`
+  } else {
+    audioError.value = 'Unknown audio playback error'
+  }
+  isPlaying.value = false
+}
+
 // Initialize on mount
 onMounted(async () => {
   await fetchChannels()
@@ -239,6 +319,26 @@ onMounted(async () => {
   cursor: not-allowed;
 }
 
+.btn-play {
+  background: rgba(46, 204, 113, 0.2);
+  color: #2ecc71;
+  border: 1px solid rgba(46, 204, 113, 0.4);
+  padding: 8px 16px;
+  border-radius: 4px;
+  cursor: pointer;
+  font-weight: bold;
+  transition: background 0.3s;
+}
+
+.btn-play:hover:not(:disabled) {
+  background: rgba(46, 204, 113, 0.35);
+}
+
+.btn-play:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
 .channel-select {
   padding: 8px 12px;
   border-radius: 4px;
@@ -513,4 +613,31 @@ onMounted(async () => {
   color: #999;
   font-size: 0.9em;
 }
+
+.audio-player-container {
+  margin: 12px 0 24px;
+  padding: 16px;
+  border-radius: 8px;
+  background: rgba(0, 0, 0, 0.2);
+  border: 1px solid #333;
+  display: flex;
+  gap: 12px;
+  align-items: center;
+}
+
+.audio-error {
+  margin: 0;
+  color: #ff6b6b;
+  flex: 1;
+}
+
+.btn-stop {
+  padding: 8px 16px;
+  border-radius: 4px;
+  border: none;
+  cursor: pointer;
+  background: rgba(231, 76, 60, 0.2);
+  color: #e74c3c;
+  font-weight: bold;
+}
 </style>
diff --git a/pmoapp/webapp/src/components/UpnpExplorer.vue b/pmoapp/webapp/src/components/UpnpExplorer.vue
index e7c94a67..84e253cf 100644
--- a/pmoapp/webapp/src/components/UpnpExplorer.vue
+++ b/pmoapp/webapp/src/components/UpnpExplorer.vue
@@ -55,13 +55,37 @@
             </div>
 
             <!-- Services -->
-            <div v-else class="services-list">
-              <ServicePanel
-                v-for="service in device.services"
-                :key="service.name"
-                :service="service"
-                :device-udn="device.udn"
-              />
+            <div v-else class="device-content">
+              <div class="device-summary">
+                <div class="meta-row">
+                  <span class="meta-label">UDN:</span>
+                  <code class="meta-value">{{ device.udn }}</code>
+                </div>
+                <div class="meta-row" v-if="device.description_url">
+                  <span class="meta-label">Description:</span>
+                  <a
+                    :href="device.description_url"
+                    target="_blank"
+                    rel="noopener"
+                    class="meta-link"
+                  >
+                    View XML
+                  </a>
+                </div>
+                <div class="meta-row" v-if="device.base_url">
+                  <span class="meta-label">Base URL:</span>
+                  <code class="meta-value">{{ device.base_url }}</code>
+                </div>
+              </div>
+
+              <div class="services-list">
+                <ServicePanel
+                  v-for="service in device.services"
+                  :key="service.name"
+                  :service="service"
+                  :device-udn="device.udn"
+                />
+              </div>
             </div>
           </div>
         </transition>
@@ -353,6 +377,51 @@ onUnmounted(() => {
   color: #95a5a6;
 }
 
+.device-content {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.device-summary {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.75rem 1.5rem;
+  padding: 0.75rem 1rem;
+  border-radius: 6px;
+  background: rgba(0, 0, 0, 0.25);
+  border: 1px solid rgba(52, 152, 219, 0.25);
+}
+
+.meta-row {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.9rem;
+}
+
+.meta-label {
+  font-weight: 600;
+  color: #95a5a6;
+}
+
+.meta-value {
+  background: rgba(44, 62, 80, 0.6);
+  padding: 0.25rem 0.5rem;
+  border-radius: 4px;
+  color: #ecf0f1;
+}
+
+.meta-link {
+  color: #1abc9c;
+  text-decoration: none;
+  font-weight: 600;
+}
+
+.meta-link:hover {
+  text-decoration: underline;
+}
+
 .services-list {
   display: flex;
   flex-direction: column;
diff --git a/pmoapp/webapp/src/components/upnp/ActionsList.vue b/pmoapp/webapp/src/components/upnp/ActionsList.vue
index 4447242d..86e49f1f 100644
--- a/pmoapp/webapp/src/components/upnp/ActionsList.vue
+++ b/pmoapp/webapp/src/components/upnp/ActionsList.vue
@@ -30,6 +30,13 @@
               <span v-if="action.out_arguments.length > 0" class="badge out-badge" title="Output arguments">
                 ⬅️ {{ action.out_arguments.length }}
               </span>
+              <span
+                v-if="action.stateless"
+                class="badge stateless-badge"
+                title="Does not mutate state variables"
+              >
+                🧊 Stateless
+              </span>
               <span class="expand-indicator">
                 {{ expandedAction === action.name ? '▼' : '▶' }}
               </span>
@@ -38,6 +45,12 @@
 
           <transition name="expand-args">
             <div v-if="expandedAction === action.name" class="action-details">
+              <div v-if="action.stateless" class="action-flags">
+                <span class="stateless-pill">
+                  Stateless action — no state variables updated
+                </span>
+              </div>
+
               <!-- Input arguments -->
               <div v-if="action.in_arguments.length > 0" class="arguments-section">
                 <h5 class="section-title">
@@ -299,6 +312,12 @@ onMounted(() => {
   border: 1px solid rgba(46, 204, 113, 0.3);
 }
 
+.stateless-badge {
+  background: rgba(155, 89, 182, 0.2);
+  color: #9b59b6;
+  border: 1px solid rgba(155, 89, 182, 0.3);
+}
+
 .expand-indicator {
   color: #3498db;
   font-size: 0.9rem;
@@ -316,6 +335,23 @@ onMounted(() => {
   border-top: 1px solid rgba(52, 152, 219, 0.2);
 }
 
+.action-flags {
+  margin-top: 0.75rem;
+}
+
+.stateless-pill {
+  display: inline-block;
+  padding: 0.3rem 0.6rem;
+  border-radius: 999px;
+  background: rgba(155, 89, 182, 0.15);
+  border: 1px solid rgba(155, 89, 182, 0.25);
+  color: #d2a6e6;
+  font-size: 0.8rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.6px;
+}
+
 .arguments-section {
   margin-top: 1rem;
 }
diff --git a/pmoaudio/examples/multiroom_demo.rs b/pmoaudio/examples/multiroom_demo.rs
index 8464d8a7..1cae4671 100644
--- a/pmoaudio/examples/multiroom_demo.rs
+++ b/pmoaudio/examples/multiroom_demo.rs
@@ -49,7 +49,10 @@ async fn main() {
     tokio::spawn(async move {
         let mut source = SourceNode::new();
         source.add_subscriber(buffer_tx);
-        source.generate_chunks(30, 4800, 48000, 440.0).await.unwrap();
+        source
+            .generate_chunks(30, 4800, 48000, 440.0)
+            .await
+            .unwrap();
     });
 
     println!("Waiting for all rooms to finish...\n");
diff --git a/pmoaudio/examples/multiroom_volume_demo.rs b/pmoaudio/examples/multiroom_volume_demo.rs
index d6df0bb0..5212b79a 100644
--- a/pmoaudio/examples/multiroom_volume_demo.rs
+++ b/pmoaudio/examples/multiroom_volume_demo.rs
@@ -7,8 +7,7 @@
 //! - Système d'événements pour la communication entre nodes
 
 use pmoaudio::{
-    ChromecastConfig, ChromecastSink, DiskSink, DiskSinkConfig, SourceNode,
-    VolumeNode,
+    ChromecastConfig, ChromecastSink, DiskSink, DiskSinkConfig, SourceNode, VolumeNode,
 };
 use tokio::sync::mpsc;
 
@@ -146,8 +145,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     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!(
+        "- 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: {}",
diff --git a/pmoaudio/examples/quick_start.rs b/pmoaudio/examples/quick_start.rs
index 6068592d..dd5c4c7d 100644
--- a/pmoaudio/examples/quick_start.rs
+++ b/pmoaudio/examples/quick_start.rs
@@ -73,10 +73,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // 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)
+            10,    // nombre de chunks
+            4800,  // samples par chunk (100ms @ 48kHz)
+            48000, // sample rate
+            440.0, // fréquence (La 440 Hz)
         )
         .await?;
 
diff --git a/pmoaudio/src/audio_chunk.rs b/pmoaudio/src/audio_chunk.rs
index afb91540..882a1699 100644
--- a/pmoaudio/src/audio_chunk.rs
+++ b/pmoaudio/src/audio_chunk.rs
@@ -90,7 +90,13 @@ impl AudioChunk {
     }
 
     /// Crée un nouveau chunk audio avec un gain spécifique
-    pub fn with_gain(order: u64, left: Vec<f32>, right: Vec<f32>, sample_rate: u32, gain: f32) -> Self {
+    pub fn with_gain(
+        order: u64,
+        left: Vec<f32>,
+        right: Vec<f32>,
+        sample_rate: u32,
+        gain: f32,
+    ) -> Self {
         Self {
             order,
             left: Arc::new(left),
diff --git a/pmoaudio/src/lib.rs b/pmoaudio/src/lib.rs
index 89c56e5d..c92db8c6 100644
--- a/pmoaudio/src/lib.rs
+++ b/pmoaudio/src/lib.rs
@@ -76,13 +76,13 @@
 //! - **RwLock** : Pour partage concurrent du compteur [`TimerNode`]
 
 mod audio_chunk;
-mod nodes;
 pub mod events;
+mod nodes;
 
 pub use audio_chunk::AudioChunk;
 pub use events::{
-    AudioDataEvent, EventPublisher, EventReceiver, NodeEvent, NodeListener,
-    SourceNameUpdateEvent, VolumeChangeEvent,
+    AudioDataEvent, EventPublisher, EventReceiver, NodeEvent, NodeListener, SourceNameUpdateEvent,
+    VolumeChangeEvent,
 };
 pub use nodes::{
     buffer_node::BufferNode,
diff --git a/pmoaudio/src/nodes/buffer_node.rs b/pmoaudio/src/nodes/buffer_node.rs
index b93703bd..86bee223 100644
--- a/pmoaudio/src/nodes/buffer_node.rs
+++ b/pmoaudio/src/nodes/buffer_node.rs
@@ -1,4 +1,7 @@
-use crate::{AudioChunk, nodes::{AudioError, MultiSubscriberNode}};
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
 use std::collections::VecDeque;
 use std::sync::Arc;
 use tokio::sync::{mpsc, RwLock};
diff --git a/pmoaudio/src/nodes/chromecast_sink.rs b/pmoaudio/src/nodes/chromecast_sink.rs
index 6172b609..17b575ad 100644
--- a/pmoaudio/src/nodes/chromecast_sink.rs
+++ b/pmoaudio/src/nodes/chromecast_sink.rs
@@ -189,10 +189,7 @@ impl ChromecastSink {
         // Établir la connexion
         self.connect().await?;
 
-        let mut stats = ChromecastStats::new(
-            self.node_id.clone(),
-            self.config.device_name.clone(),
-        );
+        let mut stats = ChromecastStats::new(self.node_id.clone(), self.config.device_name.clone());
 
         // Boucle principale
         while let Some(chunk) = self.rx.recv().await {
diff --git a/pmoaudio/src/nodes/decoder_node.rs b/pmoaudio/src/nodes/decoder_node.rs
index 9cbe1e10..087ca3b9 100644
--- a/pmoaudio/src/nodes/decoder_node.rs
+++ b/pmoaudio/src/nodes/decoder_node.rs
@@ -1,4 +1,7 @@
-use crate::{AudioChunk, nodes::{AudioError, MultiSubscriberNode}};
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
 use std::sync::Arc;
 use tokio::sync::mpsc;
 
@@ -56,10 +59,10 @@ impl DecoderNode {
 
                     if src_idx < left_data.len() - 1 {
                         let frac = src_pos - src_idx as f64;
-                        let left_sample =
-                            left_data[src_idx] * (1.0 - frac as f32) + left_data[src_idx + 1] * frac as f32;
-                        let right_sample =
-                            right_data[src_idx] * (1.0 - frac as f32) + right_data[src_idx + 1] * frac as f32;
+                        let left_sample = left_data[src_idx] * (1.0 - frac as f32)
+                            + left_data[src_idx + 1] * frac as f32;
+                        let right_sample = right_data[src_idx] * (1.0 - frac as f32)
+                            + right_data[src_idx + 1] * frac as f32;
 
                         new_left.push(left_sample);
                         new_right.push(right_sample);
@@ -69,7 +72,8 @@ impl DecoderNode {
                     }
                 }
 
-                let new_chunk = AudioChunk::new(chunk.order, new_left, new_right, target_sample_rate);
+                let new_chunk =
+                    AudioChunk::new(chunk.order, new_left, new_right, target_sample_rate);
                 self.subscribers.push(Arc::new(new_chunk)).await?;
             }
         }
diff --git a/pmoaudio/src/nodes/disk_sink.rs b/pmoaudio/src/nodes/disk_sink.rs
index e5f5d043..92e76e9f 100644
--- a/pmoaudio/src/nodes/disk_sink.rs
+++ b/pmoaudio/src/nodes/disk_sink.rs
@@ -3,11 +3,7 @@
 //! 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 crate::{events::SourceNameUpdateEvent, nodes::AudioError, AudioChunk};
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::fs::File;
@@ -161,7 +157,13 @@ impl DiskSink {
             // 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 { '_' })
+                .map(|c| {
+                    if c.is_alphanumeric() || c == '_' || c == '-' {
+                        c
+                    } else {
+                        '_'
+                    }
+                })
                 .collect::<String>();
 
             format!("{}.{}", clean_name, self.config.format.extension())
@@ -180,9 +182,9 @@ impl DiskSink {
 
         // 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)))?;
+            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
@@ -328,10 +330,9 @@ impl AudioFileWriter {
             bytes.extend_from_slice(&sample_i16.to_le_bytes());
         }
 
-        self.file
-            .write_all(&bytes)
-            .await
-            .map_err(|e| AudioError::ProcessingError(format!("Failed to write audio data: {}", e)))?;
+        self.file.write_all(&bytes).await.map_err(|e| {
+            AudioError::ProcessingError(format!("Failed to write audio data: {}", e))
+        })?;
 
         self.total_samples += chunk.len();
         Ok(())
@@ -361,10 +362,9 @@ impl AudioFileWriter {
         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)))?;
+        self.file.write_all(&header).await.map_err(|e| {
+            AudioError::ProcessingError(format!("Failed to write WAV header: {}", e))
+        })?;
 
         Ok(())
     }
@@ -378,24 +378,37 @@ impl AudioFileWriter {
 
             // 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(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
+                .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))
-        })?;
+        self.file
+            .flush()
+            .await
+            .map_err(|e| AudioError::ProcessingError(format!("Failed to flush file: {}", e)))?;
 
         Ok(())
     }
diff --git a/pmoaudio/src/nodes/dsp_node.rs b/pmoaudio/src/nodes/dsp_node.rs
index 9d88086c..57383472 100644
--- a/pmoaudio/src/nodes/dsp_node.rs
+++ b/pmoaudio/src/nodes/dsp_node.rs
@@ -1,4 +1,7 @@
-use crate::{AudioChunk, nodes::{AudioError, MultiSubscriberNode}};
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
 use std::sync::Arc;
 use tokio::sync::mpsc;
 
@@ -46,12 +49,8 @@ impl DspNode {
                     *sample *= self.gain;
                 }
 
-                let new_chunk = AudioChunk::new(
-                    chunk.order,
-                    left_data,
-                    right_data,
-                    chunk.sample_rate,
-                );
+                let new_chunk =
+                    AudioChunk::new(chunk.order, left_data, right_data, chunk.sample_rate);
 
                 self.subscribers.push(Arc::new(new_chunk)).await?;
             }
@@ -118,12 +117,7 @@ impl LowPassDspNode {
                 new_right.push(self.prev_right);
             }
 
-            let new_chunk = AudioChunk::new(
-                chunk.order,
-                new_left,
-                new_right,
-                chunk.sample_rate,
-            );
+            let new_chunk = AudioChunk::new(chunk.order, new_left, new_right, chunk.sample_rate);
 
             self.subscribers.push(Arc::new(new_chunk)).await?;
         }
diff --git a/pmoaudio/src/nodes/mod.rs b/pmoaudio/src/nodes/mod.rs
index 3a006def..6cf5dc79 100644
--- a/pmoaudio/src/nodes/mod.rs
+++ b/pmoaudio/src/nodes/mod.rs
@@ -59,10 +59,7 @@ impl SingleSubscriberNode {
     }
 
     pub async fn push(&self, chunk: Arc<AudioChunk>) -> Result<(), AudioError> {
-        self.tx
-            .send(chunk)
-            .await
-            .map_err(|_| AudioError::SendError)
+        self.tx.send(chunk).await.map_err(|_| AudioError::SendError)
     }
 }
 
diff --git a/pmoaudio/src/nodes/mpd_sink.rs b/pmoaudio/src/nodes/mpd_sink.rs
index 1409ee10..4b1ae09f 100644
--- a/pmoaudio/src/nodes/mpd_sink.rs
+++ b/pmoaudio/src/nodes/mpd_sink.rs
@@ -197,7 +197,9 @@ impl MpdSink {
     /// 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()));
+            return Err(AudioError::ProcessingError(
+                "Not connected to MPD".to_string(),
+            ));
         }
 
         // Dans une vraie implémentation:
diff --git a/pmoaudio/src/nodes/sink_node.rs b/pmoaudio/src/nodes/sink_node.rs
index fff47537..bc651456 100644
--- a/pmoaudio/src/nodes/sink_node.rs
+++ b/pmoaudio/src/nodes/sink_node.rs
@@ -1,4 +1,4 @@
-use crate::{AudioChunk, nodes::AudioError};
+use crate::{nodes::AudioError, AudioChunk};
 use std::sync::Arc;
 use tokio::sync::mpsc;
 
@@ -115,11 +115,13 @@ impl SinkStats {
         let sum_squares_left: f64 = chunk.left.iter().map(|&x| (x * x) as f64).sum();
         let sum_squares_right: f64 = chunk.right.iter().map(|&x| (x * x) as f64).sum();
 
-        self.rms_left = ((self.rms_left.powi(2) * (self.total_samples - chunk.len() as u64) as f64
+        self.rms_left = ((self.rms_left.powi(2)
+            * (self.total_samples - chunk.len() as u64) as f64
             + sum_squares_left)
             / self.total_samples as f64)
             .sqrt();
-        self.rms_right = ((self.rms_right.powi(2) * (self.total_samples - chunk.len() as u64) as f64
+        self.rms_right = ((self.rms_right.powi(2)
+            * (self.total_samples - chunk.len() as u64) as f64
             + sum_squares_right)
             / self.total_samples as f64)
             .sqrt();
diff --git a/pmoaudio/src/nodes/source_node.rs b/pmoaudio/src/nodes/source_node.rs
index a93a9fc9..bef7e5cd 100644
--- a/pmoaudio/src/nodes/source_node.rs
+++ b/pmoaudio/src/nodes/source_node.rs
@@ -1,4 +1,7 @@
-use crate::{AudioChunk, nodes::{AudioError, MultiSubscriberNode}};
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
 use std::sync::Arc;
 use tokio::sync::mpsc;
 
@@ -63,12 +66,8 @@ impl SourceNode {
         sample_rate: u32,
     ) -> Result<(), AudioError> {
         for i in 0..count {
-            let chunk = AudioChunk::new(
-                i,
-                vec![0.0; chunk_size],
-                vec![0.0; chunk_size],
-                sample_rate,
-            );
+            let chunk =
+                AudioChunk::new(i, vec![0.0; chunk_size], vec![0.0; chunk_size], sample_rate);
             self.subscribers.push(Arc::new(chunk)).await?;
         }
         Ok(())
diff --git a/pmoaudio/src/nodes/timer_node.rs b/pmoaudio/src/nodes/timer_node.rs
index 6123323f..c82060b5 100644
--- a/pmoaudio/src/nodes/timer_node.rs
+++ b/pmoaudio/src/nodes/timer_node.rs
@@ -1,4 +1,7 @@
-use crate::{AudioChunk, nodes::{AudioError, MultiSubscriberNode}};
+use crate::{
+    nodes::{AudioError, MultiSubscriberNode},
+    AudioChunk,
+};
 use std::sync::Arc;
 use tokio::sync::{mpsc, RwLock};
 
diff --git a/pmoaudio/tests/integration_test.rs b/pmoaudio/tests/integration_test.rs
index 2d199a2f..4c038217 100644
--- a/pmoaudio/tests/integration_test.rs
+++ b/pmoaudio/tests/integration_test.rs
@@ -32,7 +32,10 @@ async fn test_complete_pipeline() {
     tokio::spawn(async move {
         let mut source = SourceNode::new();
         source.add_subscriber(decoder_tx);
-        source.generate_chunks(10, 4800, 48000, 440.0).await.unwrap();
+        source
+            .generate_chunks(10, 4800, 48000, 440.0)
+            .await
+            .unwrap();
     });
 
     // Attendre la fin
@@ -73,7 +76,10 @@ async fn test_multiroom_buffering() {
     tokio::spawn(async move {
         let mut source = SourceNode::new();
         source.add_subscriber(buffer_tx);
-        source.generate_chunks(20, 1000, 48000, 440.0).await.unwrap();
+        source
+            .generate_chunks(20, 1000, 48000, 440.0)
+            .await
+            .unwrap();
     });
 
     let stats1 = sink1_handle.await.unwrap();
@@ -108,7 +114,10 @@ async fn test_timer_accuracy() {
         source.add_subscriber(timer_tx);
 
         // 48000 samples à 48kHz = 1 seconde
-        source.generate_chunks(1, 48000, 48000, 440.0).await.unwrap();
+        source
+            .generate_chunks(1, 48000, 48000, 440.0)
+            .await
+            .unwrap();
     });
 
     sink_handle.await.unwrap();
diff --git a/pmoaudiocache/examples/test_flac_debug.rs b/pmoaudiocache/examples/test_flac_debug.rs
index e377cc82..f62ade3b 100644
--- a/pmoaudiocache/examples/test_flac_debug.rs
+++ b/pmoaudiocache/examples/test_flac_debug.rs
@@ -30,12 +30,20 @@ async fn main() -> anyhow::Result<()> {
         let header = &data[0..4];
         if header == b"fLaC" {
             println!("✓ File is FLAC!");
-        } else if header[0..3] == *b"ID3" || (header.len() >= 2 && header[0] == 0xFF && (header[1] & 0xE0) == 0xE0) {
+        } else if header[0..3] == *b"ID3"
+            || (header.len() >= 2 && header[0] == 0xFF && (header[1] & 0xE0) == 0xE0)
+        {
             println!("✗ File is still MP3!");
-            println!("   Header: {:02X} {:02X} {:02X} {:02X}", header[0], header[1], header[2], header[3]);
+            println!(
+                "   Header: {:02X} {:02X} {:02X} {:02X}",
+                header[0], header[1], header[2], header[3]
+            );
         } else {
             println!("? Unknown format");
-            println!("   Header: {:02X} {:02X} {:02X} {:02X}", header[0], header[1], header[2], header[3]);
+            println!(
+                "   Header: {:02X} {:02X} {:02X} {:02X}",
+                header[0], header[1], header[2], header[3]
+            );
         }
     }
 
diff --git a/pmoaudiocache/src/cache.rs b/pmoaudiocache/src/cache.rs
index da3609ea..0d765185 100644
--- a/pmoaudiocache/src/cache.rs
+++ b/pmoaudiocache/src/cache.rs
@@ -70,7 +70,10 @@ fn create_flac_transformer() -> StreamTransformer {
                 buffer.extend_from_slice(&chunk);
             }
 
-            tracing::debug!("Downloaded {} bytes total, starting FLAC conversion", buffer.len());
+            tracing::debug!(
+                "Downloaded {} bytes total, starting FLAC conversion",
+                buffer.len()
+            );
 
             // 2. Si c'est déjà du FLAC, on l'écrit directement
             if buffer.len() >= 4 && &buffer[0..4] == b"fLaC" {
@@ -85,21 +88,26 @@ fn create_flac_transformer() -> StreamTransformer {
 
             // 3. Décoder l'audio avec Symphonia
             let (samples, channels, sample_rate, bits_per_sample) = {
+                use std::io::Cursor;
                 use symphonia::core::audio::SampleBuffer;
                 use symphonia::core::codecs::{DecoderOptions, CODEC_TYPE_NULL};
+                use symphonia::core::errors::Error as SymphoniaError;
                 use symphonia::core::formats::FormatOptions;
                 use symphonia::core::io::MediaSourceStream;
                 use symphonia::core::meta::MetadataOptions;
                 use symphonia::core::probe::Hint;
-                use symphonia::core::errors::Error as SymphoniaError;
-                use std::io::Cursor;
 
                 let cursor = Cursor::new(buffer);
                 let mss = MediaSourceStream::new(Box::new(cursor), Default::default());
 
                 let hint = Hint::new();
                 let probed = symphonia::default::get_probe()
-                    .format(&hint, mss, &FormatOptions::default(), &MetadataOptions::default())
+                    .format(
+                        &hint,
+                        mss,
+                        &FormatOptions::default(),
+                        &MetadataOptions::default(),
+                    )
                     .map_err(|e| format!("Failed to probe format: {}", e))?;
 
                 let mut format = probed.format;
@@ -114,15 +122,18 @@ fn create_flac_transformer() -> StreamTransformer {
                     .make(&track.codec_params, &DecoderOptions::default())
                     .map_err(|e| format!("Failed to create decoder: {}", e))?;
 
-                let channels = track.codec_params.channels
+                let channels = track
+                    .codec_params
+                    .channels
                     .ok_or_else(|| "No channel info".to_string())?
                     .count();
 
-                let sample_rate = track.codec_params.sample_rate
+                let sample_rate = track
+                    .codec_params
+                    .sample_rate
                     .ok_or_else(|| "No sample rate info".to_string())?;
 
-                let bits_per_sample = track.codec_params.bits_per_sample
-                    .unwrap_or(16);
+                let bits_per_sample = track.codec_params.bits_per_sample.unwrap_or(16);
 
                 let mut samples_i32 = Vec::new();
                 let track_id = track.id;
@@ -135,7 +146,9 @@ fn create_flac_transformer() -> StreamTransformer {
                             decoder.reset();
                             continue;
                         }
-                        Err(SymphoniaError::IoError(e)) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                        Err(SymphoniaError::IoError(e))
+                            if e.kind() == std::io::ErrorKind::UnexpectedEof =>
+                        {
                             break;
                         }
                         Err(e) => return Err(format!("Decode error: {}", e)),
@@ -183,13 +196,13 @@ fn create_flac_transformer() -> StreamTransformer {
                         tracing::debug!("Normalizing to 16-bit");
                         let samples = samples_i32.iter().map(|&s| (s >> 16) as i32).collect();
                         (samples, 16)
-                    },
+                    }
                     17..=24 => {
                         // Pour 17-24 bits, normaliser vers la plage 24-bit
                         tracing::debug!("Normalizing to 24-bit");
                         let samples = samples_i32.iter().map(|&s| (s >> 8) as i32).collect();
                         (samples, 24)
-                    },
+                    }
                     _ => {
                         // Pour 25-32 bits, garder la pleine échelle i32
                         tracing::debug!("Keeping 32-bit");
@@ -200,15 +213,20 @@ fn create_flac_transformer() -> StreamTransformer {
                 (normalized_samples, channels, sample_rate, target_bits)
             };
 
-            tracing::debug!("Encoding to FLAC: {} samples, {} channels, {} Hz, {} bits",
-                samples.len(), channels, sample_rate, bits_per_sample);
+            tracing::debug!(
+                "Encoding to FLAC: {} samples, {} channels, {} Hz, {} bits",
+                samples.len(),
+                channels,
+                sample_rate,
+                bits_per_sample
+            );
 
             // 4. Encoder en FLAC avec flacenc
             // Note: L'encodage FLAC est une opération bloquante/CPU-intensive,
             // donc nous l'exécutons dans un thread bloquant pour ne pas bloquer le runtime Tokio
             let flac_data = tokio::task::spawn_blocking(move || {
-                use flacenc::component::BitRepr;
                 use flacenc::bitsink::ByteSink;
+                use flacenc::component::BitRepr;
                 use flacenc::error::Verify;
 
                 let config = flacenc::config::Encoder::default()
@@ -222,15 +240,13 @@ fn create_flac_transformer() -> StreamTransformer {
                     sample_rate as usize,
                 );
 
-                let flac_stream = flacenc::encode_with_fixed_block_size(
-                    &config,
-                    source,
-                    config.block_size,
-                )
-                .map_err(|e| format!("FLAC encode error: {:?}", e))?;
+                let flac_stream =
+                    flacenc::encode_with_fixed_block_size(&config, source, config.block_size)
+                        .map_err(|e| format!("FLAC encode error: {:?}", e))?;
 
                 let mut sink = ByteSink::new();
-                flac_stream.write(&mut sink)
+                flac_stream
+                    .write(&mut sink)
                     .map_err(|e| format!("FLAC write error: {:?}", e))?;
 
                 Ok::<Vec<u8>, String>(sink.into_inner())
@@ -241,7 +257,9 @@ fn create_flac_transformer() -> StreamTransformer {
             tracing::debug!("FLAC encoding complete: {} bytes", flac_data.len());
 
             // 5. Écrire le fichier FLAC
-            file.write_all(&flac_data).await.map_err(|e| e.to_string())?;
+            file.write_all(&flac_data)
+                .await
+                .map_err(|e| e.to_string())?;
             file.flush().await.map_err(|e| e.to_string())?;
 
             // 6. Mettre à jour la progression finale
@@ -328,13 +346,17 @@ pub async fn add_with_metadata_extraction(
     let metadata_json = serde_json::to_string(&metadata)?;
 
     // Stocker dans la DB
-    cache.db.update_metadata(&pk, &metadata_json)
+    cache
+        .db
+        .update_metadata(&pk, &metadata_json)
         .map_err(|e| anyhow::anyhow!("Database error: {}", e))?;
 
     // Mettre à jour la collection si les métadonnées en fournissent une
     if collection.is_none() {
         if let Some(auto_collection) = metadata.collection_key() {
-            cache.db.add(&pk, url, Some(&auto_collection))
+            cache
+                .db
+                .add(&pk, url, Some(&auto_collection))
                 .map_err(|e| anyhow::anyhow!("Database error: {}", e))?;
         }
     }
@@ -366,7 +388,9 @@ pub async fn add_with_metadata_extraction(
 /// # }
 /// ```
 pub fn get_metadata(cache: &Cache, pk: &str) -> Result<crate::metadata::AudioMetadata> {
-    let metadata_json = cache.db.get_metadata_json(pk)
+    let metadata_json = cache
+        .db
+        .get_metadata_json(pk)
         .map_err(|e| anyhow::anyhow!("Database error: {}", e))?
         .ok_or_else(|| anyhow::anyhow!("No metadata found for pk: {}", pk))?;
 
@@ -375,4 +399,3 @@ pub fn get_metadata(cache: &Cache, pk: &str) -> Result<crate::metadata::AudioMet
 
     Ok(metadata)
 }
-
diff --git a/pmoaudiocache/src/flac.rs b/pmoaudiocache/src/flac.rs
index 16f22f29..1252e91e 100644
--- a/pmoaudiocache/src/flac.rs
+++ b/pmoaudiocache/src/flac.rs
@@ -4,6 +4,7 @@
 //! pour standardiser le stockage dans le cache.
 
 use anyhow::{anyhow, Result};
+use std::io::Cursor;
 use symphonia::core::audio::SampleBuffer;
 use symphonia::core::codecs::{DecoderOptions, CODEC_TYPE_NULL};
 use symphonia::core::errors::Error as SymphoniaError;
@@ -11,7 +12,6 @@ use symphonia::core::formats::FormatOptions;
 use symphonia::core::io::MediaSourceStream;
 use symphonia::core::meta::MetadataOptions;
 use symphonia::core::probe::Hint;
-use std::io::Cursor;
 
 /// Convertit des données audio en FLAC
 ///
@@ -54,7 +54,12 @@ pub fn convert_to_flac(data: &[u8], extension: Option<&str>) -> Result<Vec<u8>>
 
     // Prober le format
     let probed = symphonia::default::get_probe()
-        .format(&hint, mss, &FormatOptions::default(), &MetadataOptions::default())
+        .format(
+            &hint,
+            mss,
+            &FormatOptions::default(),
+            &MetadataOptions::default(),
+        )
         .map_err(|e| anyhow!("Impossible de détecter le format audio: {}", e))?;
 
     let mut format = probed.format;
diff --git a/pmoaudiocache/src/lib.rs b/pmoaudiocache/src/lib.rs
index 4715666c..090060dc 100644
--- a/pmoaudiocache/src/lib.rs
+++ b/pmoaudiocache/src/lib.rs
@@ -131,14 +131,14 @@
 //! - [`pmoserver`] : Serveur HTTP
 
 pub mod cache;
-pub mod metadata;
 pub mod flac;
+pub mod metadata;
 
 #[cfg(feature = "pmoserver")]
 pub mod openapi;
 
 // Re-exports principaux
-pub use cache::{Cache, AudioConfig, new_cache, add_with_metadata_extraction, get_metadata};
+pub use cache::{add_with_metadata_extraction, get_metadata, new_cache, AudioConfig, Cache};
 pub use metadata::AudioMetadata;
 
 #[cfg(feature = "pmoserver")]
@@ -161,7 +161,11 @@ pub trait AudioCacheExt {
     /// # Returns
     ///
     /// * `Arc<Cache>` - Instance partagée du cache
-    async fn init_audio_cache(&mut self, cache_dir: &str, limit: usize) -> anyhow::Result<std::sync::Arc<Cache>>;
+    async fn init_audio_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> anyhow::Result<std::sync::Arc<Cache>>;
 
     /// Initialise le cache audio avec la configuration par défaut.
     ///
@@ -170,7 +174,7 @@ pub trait AudioCacheExt {
 }
 
 #[cfg(feature = "pmoserver")]
-use pmocache::pmoserver_ext::{create_file_router, create_api_router};
+use pmocache::pmoserver_ext::{create_api_router, create_file_router};
 #[cfg(feature = "pmoserver")]
 use std::sync::Arc;
 #[cfg(feature = "pmoserver")]
@@ -178,14 +182,18 @@ use utoipa::OpenApi;
 
 #[cfg(feature = "pmoserver")]
 impl AudioCacheExt for pmoserver::Server {
-    async fn init_audio_cache(&mut self, cache_dir: &str, limit: usize) -> anyhow::Result<Arc<Cache>> {
+    async fn init_audio_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> anyhow::Result<Arc<Cache>> {
         let cache = Arc::new(crate::cache::new_cache(cache_dir, limit)?);
 
         // Router de fichiers pour servir les pistes FLAC
         // Routes: GET /audio/tracks/{pk} et GET /audio/tracks/{pk}/{param}
         let file_router = create_file_router(
             cache.clone(),
-            "audio/flac"  // Content-Type
+            "audio/flac", // Content-Type
         );
         self.add_router("/", file_router).await;
 
diff --git a/pmoaudiocache/src/metadata.rs b/pmoaudiocache/src/metadata.rs
index 1a9e5512..964ed896 100644
--- a/pmoaudiocache/src/metadata.rs
+++ b/pmoaudiocache/src/metadata.rs
@@ -87,12 +87,12 @@ impl AudioMetadata {
     /// println!("Titre: {:?}", metadata.title);
     /// ```
     pub fn from_file(path: &Path) -> Result<Self> {
-        let tagged_file = Probe::open(path)?
-            .options(ParseOptions::new())
-            .read()?;
+        let tagged_file = Probe::open(path)?.options(ParseOptions::new()).read()?;
 
         let properties = tagged_file.properties();
-        let tag = tagged_file.primary_tag().or_else(|| tagged_file.first_tag());
+        let tag = tagged_file
+            .primary_tag()
+            .or_else(|| tagged_file.first_tag());
 
         let mut metadata = Self {
             title: None,
@@ -138,7 +138,9 @@ impl AudioMetadata {
             .read()?;
 
         let properties = tagged_file.properties();
-        let tag = tagged_file.primary_tag().or_else(|| tagged_file.first_tag());
+        let tag = tagged_file
+            .primary_tag()
+            .or_else(|| tagged_file.first_tag());
 
         let mut metadata = Self {
             title: None,
diff --git a/pmocache/examples/simple_transformer.rs b/pmocache/examples/simple_transformer.rs
index 0ced7f21..ac805b7a 100644
--- a/pmocache/examples/simple_transformer.rs
+++ b/pmocache/examples/simple_transformer.rs
@@ -11,7 +11,9 @@ fn main() {
     println!("   dl.wait_until_finished().await?;\n");
 
     println!("2. Téléchargement avec transformation:");
-    println!("   let transformer: StreamTransformer = Box::new(|response, mut file, update_progress| {{");
+    println!(
+        "   let transformer: StreamTransformer = Box::new(|response, mut file, update_progress| {{"
+    );
     println!("       Box::pin(async move {{");
     println!("           let mut stream = response.bytes_stream();");
     println!("           let mut total = 0u64;");
diff --git a/pmocache/examples/test_download_transformer.rs b/pmocache/examples/test_download_transformer.rs
index a99dea4b..2f656978 100644
--- a/pmocache/examples/test_download_transformer.rs
+++ b/pmocache/examples/test_download_transformer.rs
@@ -1,7 +1,7 @@
 // Exemple d'utilisation du module download avec transformations
 
-use pmocache::download::{download_with_transformer, StreamTransformer};
 use futures_util::StreamExt;
+use pmocache::download::{download_with_transformer, StreamTransformer};
 use tokio::io::AsyncWriteExt;
 
 /// Exemple de transformer qui compresse les données en gzip
@@ -63,7 +63,13 @@ fn create_uppercase_transformer() -> StreamTransformer {
                 // Transformer en majuscules (seulement pour texte ASCII)
                 let transformed: Vec<u8> = chunk
                     .iter()
-                    .map(|&b| if b.is_ascii_lowercase() { b.to_ascii_uppercase() } else { b })
+                    .map(|&b| {
+                        if b.is_ascii_lowercase() {
+                            b.to_ascii_uppercase()
+                        } else {
+                            b
+                        }
+                    })
                     .collect();
 
                 file.write_all(&transformed)
@@ -210,7 +216,10 @@ async fn main() {
         Ok(_) => {
             println!("   ✓ Téléchargement terminé!");
             println!("   - Taille source: {} bytes", dl.current_size().await);
-            println!("   - Taille transformée: {} bytes", dl.transformed_size().await);
+            println!(
+                "   - Taille transformée: {} bytes",
+                dl.transformed_size().await
+            );
         }
         Err(e) => {
             eprintln!("   ✗ Erreur: {}", e);
@@ -223,16 +232,15 @@ async fn main() {
     let _ = std::fs::remove_file(&skip_file);
 
     let transformer = create_skip_header_transformer(100);
-    let dl = download_with_transformer(
-        &skip_file,
-        "https://www.rust-lang.org/",
-        Some(transformer),
-    );
+    let dl = download_with_transformer(&skip_file, "https://www.rust-lang.org/", Some(transformer));
 
     match dl.wait_until_finished().await {
         Ok(_) => {
             println!("   ✓ Téléchargement terminé!");
-            println!("   - Taille transformée: {} bytes", dl.transformed_size().await);
+            println!(
+                "   - Taille transformée: {} bytes",
+                dl.transformed_size().await
+            );
         }
         Err(e) => {
             eprintln!("   ✗ Erreur: {}", e);
@@ -254,7 +262,10 @@ async fn main() {
     match dl.wait_until_finished().await {
         Ok(_) => {
             println!("   ✓ Téléchargement terminé!");
-            println!("   - Taille transformée: {} bytes", dl.transformed_size().await);
+            println!(
+                "   - Taille transformée: {} bytes",
+                dl.transformed_size().await
+            );
         }
         Err(e) => {
             eprintln!("   ✗ Erreur: {}", e);
diff --git a/pmocache/src/api.rs b/pmocache/src/api.rs
index 5a043182..fad09253 100644
--- a/pmocache/src/api.rs
+++ b/pmocache/src/api.rs
@@ -92,9 +92,7 @@ pub struct ErrorResponse {
 /// Liste tous les items en cache avec leurs statistiques
 ///
 /// Retourne la liste complète des entrées du cache triées par nombre d'accès décroissant.
-pub async fn list_items<C: CacheConfig>(
-    State(cache): State<Arc<Cache<C>>>,
-) -> impl IntoResponse {
+pub async fn list_items<C: CacheConfig>(State(cache): State<Arc<Cache<C>>>) -> impl IntoResponse {
     match cache.db.get_all() {
         Ok(entries) => (StatusCode::OK, Json(entries)).into_response(),
         Err(e) => (
@@ -192,7 +190,10 @@ pub async fn add_item<C: CacheConfig>(
             .into_response();
     }
 
-    match cache.add_from_url(&req.url, req.collection.as_deref()).await {
+    match cache
+        .add_from_url(&req.url, req.collection.as_deref())
+        .await
+    {
         Ok(pk) => (
             StatusCode::CREATED,
             Json(AddItemResponse {
@@ -268,9 +269,7 @@ pub async fn delete_item<C: CacheConfig>(
 /// Purge complètement le cache
 ///
 /// Supprime tous les items et vide la base de données. Opération irréversible.
-pub async fn purge_cache<C: CacheConfig>(
-    State(cache): State<Arc<Cache<C>>>,
-) -> impl IntoResponse {
+pub async fn purge_cache<C: CacheConfig>(State(cache): State<Arc<Cache<C>>>) -> impl IntoResponse {
     match cache.purge().await {
         Ok(_) => (
             StatusCode::OK,
diff --git a/pmocache/src/cache.rs b/pmocache/src/cache.rs
index 63e45d8c..f9a59dd3 100644
--- a/pmocache/src/cache.rs
+++ b/pmocache/src/cache.rs
@@ -3,9 +3,9 @@
 //! Ce module fournit une interface générique pour gérer un cache de fichiers
 //! avec métadonnées dans une base de données SQLite.
 
-use crate::cache_trait::{FileCache, pk_from_url};
+use crate::cache_trait::{pk_from_url, FileCache};
 use crate::db::DB;
-use crate::download::{Download, download_with_transformer, StreamTransformer};
+use crate::download::{download_with_transformer, Download, StreamTransformer};
 use anyhow::{anyhow, Result};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
@@ -26,10 +26,10 @@ pub trait CacheConfig: Send + Sync {
         "file"
     }
     /// Cache name (ex: "covers", "audio", "cache")
-    fn cache_name()  -> &'static str {
+    fn cache_name() -> &'static str {
         "cache"
     }
-    /// Default param extension ("orig") 
+    /// Default param extension ("orig")
     fn default_param() -> &'static str {
         "orig"
     }
@@ -155,11 +155,7 @@ impl<C: CacheConfig> Cache<C> {
 
         // Lancer le téléchargement avec transformer
         let transformer = self.transformer_factory.as_ref().map(|f| f());
-        let download = download_with_transformer(
-            &file_path,
-            url,
-            transformer,
-        );
+        let download = download_with_transformer(&file_path, url, transformer);
 
         // Stocker dans la map des downloads en cours
         {
@@ -228,7 +224,6 @@ impl<C: CacheConfig> Cache<C> {
         self.add_from_url(url, collection).await
     }
 
-
     /// Récupère le chemin d'un fichier dans le cache
     ///
     /// # Arguments
@@ -289,8 +284,11 @@ impl<C: CacheConfig> Cache<C> {
             let file_path = self.file_path(&entry.pk);
             if !file_path.exists() {
                 // Re-télécharger le fichier manquant
-                match self.add_from_url(&entry.source_url, entry.collection.as_deref()).await {
-                    Ok(_) => {},
+                match self
+                    .add_from_url(&entry.source_url, entry.collection.as_deref())
+                    .await
+                {
+                    Ok(_) => {}
                     Err(_) => {
                         // Si le téléchargement échoue, supprimer l'entrée DB
                         self.db.delete(&entry.pk)?;
@@ -413,7 +411,9 @@ impl<C: CacheConfig> Cache<C> {
     /// * `min_size` - Taille minimale attendue en bytes
     pub async fn wait_until_min_size(&self, pk: &str, min_size: u64) -> Result<()> {
         if let Some(download) = self.get_download(pk).await {
-            download.wait_until_min_size(min_size).await
+            download
+                .wait_until_min_size(min_size)
+                .await
                 .map_err(|e| anyhow!("Download error: {}", e))
         } else {
             // Déjà terminé ou n'existe pas
@@ -432,7 +432,9 @@ impl<C: CacheConfig> Cache<C> {
     /// * `pk` - Clé primaire du fichier
     pub async fn wait_until_finished(&self, pk: &str) -> Result<()> {
         if let Some(download) = self.get_download(pk).await {
-            download.wait_until_finished().await
+            download
+                .wait_until_finished()
+                .await
                 .map_err(|e| anyhow!("Download error: {}", e))
         } else {
             // Déjà terminé ou n'existe pas
@@ -460,7 +462,8 @@ impl<C: CacheConfig> Cache<C> {
     ///
     /// Format: `{pk}.{qualifier}.{extension}`
     pub fn file_path_with_qualifier(&self, pk: &str, qualifier: &str) -> PathBuf {
-        self.dir.join(format!("{}.{}.{}", pk, qualifier, C::file_extension()))
+        self.dir
+            .join(format!("{}.{}.{}", pk, qualifier, C::file_extension()))
     }
 
     /// Valide les données avant de les stocker
@@ -499,7 +502,9 @@ impl<C: CacheConfig> Cache<C> {
                 while let Ok(Some(dir_entry)) = dir_entries.next_entry().await {
                     if let Some(filename) = dir_entry.file_name().to_str() {
                         // Format: {pk}.{param}.{ext}
-                        if filename.starts_with(&entry.pk) && filename.starts_with(&format!("{}.", entry.pk)) {
+                        if filename.starts_with(&entry.pk)
+                            && filename.starts_with(&format!("{}.", entry.pk))
+                        {
                             let _ = tokio::fs::remove_file(dir_entry.path()).await;
                         }
                     }
@@ -515,15 +520,18 @@ impl<C: CacheConfig> Cache<C> {
         }
 
         if removed > 0 {
-            tracing::info!("LRU eviction: removed {} old entries (cache size: {} -> {})",
-                removed, count, count - removed);
+            tracing::info!(
+                "LRU eviction: removed {} old entries (cache size: {} -> {})",
+                removed,
+                count,
+                count - removed
+            );
         }
 
         Ok(removed)
     }
 }
 
-
 /// Implémentation du trait FileCache pour Cache
 impl<C: CacheConfig> FileCache<C> for Cache<C> {
     fn get_cache_dir(&self) -> &Path {
diff --git a/pmocache/src/db.rs b/pmocache/src/db.rs
index 95f0c1e1..a1052024 100644
--- a/pmocache/src/db.rs
+++ b/pmocache/src/db.rs
@@ -3,9 +3,9 @@
 //! Ce module fournit une interface générique pour gérer les métadonnées
 //! des éléments en cache, avec tracking des accès et des statistiques.
 
-use rusqlite::{Connection, params};
-use serde::Serialize;
 use chrono::Utc;
+use rusqlite::{params, Connection};
+use serde::Serialize;
 use std::path::Path;
 use std::sync::Mutex;
 
@@ -32,7 +32,10 @@ pub struct CacheEntry {
     #[cfg_attr(feature = "openapi", schema(example = "2025-01-15T10:30:00Z"))]
     pub last_used: Option<String>,
     /// Métadonnées JSON optionnelles (ex: métadonnées audio, EXIF images, etc.)
-    #[cfg_attr(feature = "openapi", schema(example = r#"{"title":"Track","artist":"Artist"}"#))]
+    #[cfg_attr(
+        feature = "openapi",
+        schema(example = r#"{"title":"Track","artist":"Artist"}"#)
+    )]
     pub metadata_json: Option<String>,
 }
 
@@ -161,20 +164,16 @@ impl DB {
             self.table_name
         );
 
-        conn.query_row(
-            &sql,
-            [pk],
-            |row| {
-                Ok(CacheEntry {
-                    pk: row.get(0)?,
-                    source_url: row.get(1)?,
-                    collection: row.get(2)?,
-                    hits: row.get(3)?,
-                    last_used: row.get(4)?,
-                    metadata_json: row.get(5)?,
-                })
-            },
-        )
+        conn.query_row(&sql, [pk], |row| {
+            Ok(CacheEntry {
+                pk: row.get(0)?,
+                source_url: row.get(1)?,
+                collection: row.get(2)?,
+                hits: row.get(3)?,
+                last_used: row.get(4)?,
+                metadata_json: row.get(5)?,
+            })
+        })
     }
 
     /// Met à jour le compteur d'accès et la date du dernier accès
@@ -189,10 +188,7 @@ impl DB {
             self.table_name
         );
 
-        conn.execute(
-            &sql,
-            params![Utc::now().to_rfc3339(), pk],
-        )?;
+        conn.execute(&sql, params![Utc::now().to_rfc3339(), pk])?;
 
         Ok(())
     }
@@ -215,17 +211,18 @@ impl DB {
 
         let mut stmt = conn.prepare(&sql)?;
 
-        let entries = stmt.query_map([], |row| {
-            Ok(CacheEntry {
-                pk: row.get(0)?,
-                source_url: row.get(1)?,
-                collection: row.get(2)?,
-                hits: row.get(3)?,
-                last_used: row.get(4)?,
-                metadata_json: row.get(5)?,
-            })
-        })?
-        .collect::<rusqlite::Result<Vec<_>>>()?;
+        let entries = stmt
+            .query_map([], |row| {
+                Ok(CacheEntry {
+                    pk: row.get(0)?,
+                    source_url: row.get(1)?,
+                    collection: row.get(2)?,
+                    hits: row.get(3)?,
+                    last_used: row.get(4)?,
+                    metadata_json: row.get(5)?,
+                })
+            })?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
 
         Ok(entries)
     }
@@ -244,17 +241,18 @@ impl DB {
 
         let mut stmt = conn.prepare(&sql)?;
 
-        let entries = stmt.query_map([collection], |row| {
-            Ok(CacheEntry {
-                pk: row.get(0)?,
-                source_url: row.get(1)?,
-                collection: row.get(2)?,
-                hits: row.get(3)?,
-                last_used: row.get(4)?,
-                metadata_json: row.get(5)?,
-            })
-        })?
-        .collect::<rusqlite::Result<Vec<_>>>()?;
+        let entries = stmt
+            .query_map([collection], |row| {
+                Ok(CacheEntry {
+                    pk: row.get(0)?,
+                    source_url: row.get(1)?,
+                    collection: row.get(2)?,
+                    hits: row.get(3)?,
+                    last_used: row.get(4)?,
+                    metadata_json: row.get(5)?,
+                })
+            })?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
 
         Ok(entries)
     }
@@ -319,17 +317,18 @@ impl DB {
 
         let mut stmt = conn.prepare(&sql)?;
 
-        let entries = stmt.query_map([limit], |row| {
-            Ok(CacheEntry {
-                pk: row.get(0)?,
-                source_url: row.get(1)?,
-                collection: row.get(2)?,
-                hits: row.get(3)?,
-                last_used: row.get(4)?,
-                metadata_json: row.get(5)?,
-            })
-        })?
-        .collect::<rusqlite::Result<Vec<_>>>()?;
+        let entries = stmt
+            .query_map([limit], |row| {
+                Ok(CacheEntry {
+                    pk: row.get(0)?,
+                    source_url: row.get(1)?,
+                    collection: row.get(2)?,
+                    hits: row.get(3)?,
+                    last_used: row.get(4)?,
+                    metadata_json: row.get(5)?,
+                })
+            })?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
 
         Ok(entries)
     }
diff --git a/pmocache/src/download.rs b/pmocache/src/download.rs
index 30233818..b9336ede 100644
--- a/pmocache/src/download.rs
+++ b/pmocache/src/download.rs
@@ -1,3 +1,4 @@
+use futures_util::Future;
 use std::fs::File;
 use std::io;
 use std::path::{Path, PathBuf};
@@ -5,7 +6,6 @@ use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::RwLock;
-use futures_util::Future;
 
 /// Type pour une fonction de transformation de stream
 ///
@@ -248,20 +248,16 @@ async fn download_impl(
         .map_err(|e| e.to_string())?;
 
     // Lancer la requête
-    let response = client
-        .get(&url)
-        .send()
-        .await
-        .map_err(|e| {
-            let error = format!("Failed to fetch URL: {}", e);
-            tokio::task::block_in_place(|| {
-                tokio::runtime::Handle::current().block_on(async {
-                    let mut s = state.write().await;
-                    s.error = Some(error.clone());
-                });
+    let response = client.get(&url).send().await.map_err(|e| {
+        let error = format!("Failed to fetch URL: {}", e);
+        tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(async {
+                let mut s = state.write().await;
+                s.error = Some(error.clone());
             });
-            error
-        })?;
+        });
+        error
+    })?;
 
     // Vérifier le statut
     if !response.status().is_success() {
@@ -279,31 +275,30 @@ async fn download_impl(
     }
 
     // Créer le fichier de destination
-    let file = tokio::fs::File::create(&filename)
-        .await
-        .map_err(|e| {
-            let error = format!("Failed to create file: {}", e);
-            tokio::task::block_in_place(|| {
-                tokio::runtime::Handle::current().block_on(async {
-                    let mut s = state.write().await;
-                    s.error = Some(error.clone());
-                    s.finished = true;
-                });
+    let file = tokio::fs::File::create(&filename).await.map_err(|e| {
+        let error = format!("Failed to create file: {}", e);
+        tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(async {
+                let mut s = state.write().await;
+                s.error = Some(error.clone());
+                s.finished = true;
             });
-            error
-        })?;
+        });
+        error
+    })?;
 
     // Si un transformer est fourni, l'utiliser
     if let Some(transformer) = transformer {
         // Créer un callback pour mettre à jour la progression
         let state_clone = Arc::clone(&state);
-        let progress_callback: Arc<dyn Fn(u64) + Send + Sync> = Arc::new(move |transformed_bytes| {
-            let state = Arc::clone(&state_clone);
-            tokio::spawn(async move {
-                let mut s = state.write().await;
-                s.transformed_size = transformed_bytes;
+        let progress_callback: Arc<dyn Fn(u64) + Send + Sync> =
+            Arc::new(move |transformed_bytes| {
+                let state = Arc::clone(&state_clone);
+                tokio::spawn(async move {
+                    let mut s = state.write().await;
+                    s.transformed_size = transformed_bytes;
+                });
             });
-        });
 
         // Appeler le transformer
         match transformer(response, file, progress_callback).await {
@@ -331,8 +326,8 @@ async fn default_download(
     mut file: tokio::fs::File,
     state: Arc<RwLock<DownloadState>>,
 ) -> Result<(), String> {
-    use tokio::io::AsyncWriteExt;
     use futures_util::StreamExt;
+    use tokio::io::AsyncWriteExt;
 
     let mut stream = response.bytes_stream();
 
diff --git a/pmocache/src/lib.rs b/pmocache/src/lib.rs
index 3c281e17..91c36b3a 100644
--- a/pmocache/src/lib.rs
+++ b/pmocache/src/lib.rs
@@ -122,9 +122,9 @@
 //! - [`pmocovers`] : Cache d'images avec conversion WebP
 //! - [`pmoaudiocache`] : Cache de pistes audio
 
-pub mod db;
 pub mod cache;
 pub mod cache_trait;
+pub mod db;
 pub mod download;
 
 #[cfg(feature = "pmoserver")]
@@ -136,16 +136,13 @@ pub mod api;
 #[cfg(feature = "openapi")]
 pub mod openapi;
 
-pub use db::{DB, CacheEntry};
 pub use cache::{Cache, CacheConfig};
-pub use cache_trait::{FileCache, pk_from_url};
-pub use download::{Download, download, download_with_transformer, StreamTransformer};
+pub use cache_trait::{pk_from_url, FileCache};
+pub use db::{CacheEntry, DB};
+pub use download::{download, download_with_transformer, Download, StreamTransformer};
 
 #[cfg(feature = "pmoserver")]
-pub use pmoserver_ext::{create_file_router, create_api_router, GenericCacheExt};
+pub use pmoserver_ext::{create_api_router, create_file_router, GenericCacheExt};
 
 #[cfg(all(feature = "pmoserver", feature = "openapi"))]
-pub use api::{
-    DownloadStatus, AddItemRequest, AddItemResponse,
-    DeleteItemResponse, ErrorResponse,
-};
+pub use api::{AddItemRequest, AddItemResponse, DeleteItemResponse, DownloadStatus, ErrorResponse};
diff --git a/pmocache/src/pmoserver_ext.rs b/pmocache/src/pmoserver_ext.rs
index 6e5f81bc..afab1e87 100644
--- a/pmocache/src/pmoserver_ext.rs
+++ b/pmocache/src/pmoserver_ext.rs
@@ -49,15 +49,15 @@ use axum::{
     Router,
 };
 #[cfg(feature = "pmoserver")]
+use std::future::Future;
+#[cfg(feature = "pmoserver")]
+use std::pin::Pin;
+#[cfg(feature = "pmoserver")]
 use std::sync::Arc;
 #[cfg(feature = "pmoserver")]
 use tokio_util::io::ReaderStream;
 #[cfg(feature = "pmoserver")]
 use tracing::warn;
-#[cfg(feature = "pmoserver")]
-use std::pin::Pin;
-#[cfg(feature = "pmoserver")]
-use std::future::Future;
 
 /// Type pour le callback de génération de param
 ///
@@ -75,16 +75,20 @@ use std::future::Future;
 /// Les données générées ou None si le param n'est pas supporté
 #[cfg(feature = "pmoserver")]
 pub type ParamGenerator<C> = Arc<
-    dyn Fn(Arc<Cache<C>>, String, String)
-        -> Pin<Box<dyn Future<Output = Option<Vec<u8>>> + Send>>
-        + Send + Sync
+    dyn Fn(Arc<Cache<C>>, String, String) -> Pin<Box<dyn Future<Output = Option<Vec<u8>>> + Send>>
+        + Send
+        + Sync,
 >;
 
 /// Handler générique pour GET /{cache_name}/{cache_type}/{pk}
 /// Sert un fichier avec le param par défaut
 #[cfg(feature = "pmoserver")]
 async fn get_file<C: CacheConfig + 'static>(
-    State((cache, content_type, param_generator)): State<(Arc<Cache<C>>, &'static str, Option<ParamGenerator<C>>)>,
+    State((cache, content_type, param_generator)): State<(
+        Arc<Cache<C>>,
+        &'static str,
+        Option<ParamGenerator<C>>,
+    )>,
     Path(pk): Path<String>,
 ) -> Response {
     // Utiliser le param par défaut
@@ -96,7 +100,11 @@ async fn get_file<C: CacheConfig + 'static>(
 /// Sert un fichier avec un param spécifique
 #[cfg(feature = "pmoserver")]
 async fn get_file_with_param<C: CacheConfig + 'static>(
-    State((cache, content_type, param_generator)): State<(Arc<Cache<C>>, &'static str, Option<ParamGenerator<C>>)>,
+    State((cache, content_type, param_generator)): State<(
+        Arc<Cache<C>>,
+        &'static str,
+        Option<ParamGenerator<C>>,
+    )>,
     Path((pk, param)): Path<(String, String)>,
 ) -> Response {
     serve_file_with_streaming(&cache, &pk, &param, content_type, param_generator).await
@@ -122,11 +130,7 @@ async fn serve_file_with_streaming<C: CacheConfig>(
         if let Some(generator) = param_generator {
             if let Some(data) = generator(cache.clone(), pk.to_string(), param.to_string()).await {
                 // Le générateur a créé les données, les servir directement
-                return (
-                    StatusCode::OK,
-                    [("content-type", content_type)],
-                    data,
-                ).into_response();
+                return (StatusCode::OK, [("content-type", content_type)], data).into_response();
             }
         }
     }
@@ -207,12 +211,7 @@ async fn serve_complete_file(
     }
 
     match tokio::fs::read(&file_path).await {
-        Ok(data) => (
-            StatusCode::OK,
-            [("content-type", content_type)],
-            data,
-        )
-            .into_response(),
+        Ok(data) => (StatusCode::OK, [("content-type", content_type)], data).into_response(),
         Err(e) => {
             warn!("Error reading file {:?}: {}", file_path, e);
             (StatusCode::INTERNAL_SERVER_ERROR, "Error reading file").into_response()
@@ -332,9 +331,7 @@ pub fn create_file_router_with_generator<C: CacheConfig + 'static>(
 /// - `DELETE /{pk}` - Supprimer un item
 /// - `POST /consolidate` - Consolider le cache
 #[cfg(feature = "pmoserver")]
-pub fn create_api_router<C: CacheConfig + 'static>(
-    cache: Arc<Cache<C>>,
-) -> Router {
+pub fn create_api_router<C: CacheConfig + 'static>(cache: Arc<Cache<C>>) -> Router {
     use crate::api;
 
     Router::new()
@@ -346,8 +343,7 @@ pub fn create_api_router<C: CacheConfig + 'static>(
         )
         .route(
             "/{pk}",
-            get(api::get_item_info::<C>)
-                .delete(api::delete_item::<C>),
+            get(api::get_item_info::<C>).delete(api::delete_item::<C>),
         )
         .route("/{pk}/status", get(api::get_download_status::<C>))
         .route("/consolidate", post(api::consolidate_cache::<C>))
diff --git a/pmocovers/src/cache.rs b/pmocovers/src/cache.rs
index 50b4e424..62f0d0cb 100644
--- a/pmocovers/src/cache.rs
+++ b/pmocovers/src/cache.rs
@@ -43,12 +43,14 @@ fn create_webp_transformer() -> StreamTransformer {
             // Convertir en WebP
             let img = image::load_from_memory(&bytes)
                 .map_err(|e| format!("Image decode error: {}", e))?;
-            let webp_data = crate::webp::encode_webp(&img)
-                .map_err(|e| format!("WebP encode error: {}", e))?;
+            let webp_data =
+                crate::webp::encode_webp(&img).map_err(|e| format!("WebP encode error: {}", e))?;
 
             // Écrire et mettre à jour la progression
             use tokio::io::AsyncWriteExt;
-            file.write_all(&webp_data).await.map_err(|e| e.to_string())?;
+            file.write_all(&webp_data)
+                .await
+                .map_err(|e| e.to_string())?;
             file.flush().await.map_err(|e| e.to_string())?;
             progress(webp_data.len() as u64);
 
diff --git a/pmocovers/src/lib.rs b/pmocovers/src/lib.rs
index b99e8485..1d73204a 100644
--- a/pmocovers/src/lib.rs
+++ b/pmocovers/src/lib.rs
@@ -42,15 +42,15 @@ pub mod webp;
 #[cfg(feature = "pmoserver")]
 pub mod openapi;
 
-pub use cache::{Cache, CoversConfig, new_cache};
+pub use cache::{new_cache, Cache, CoversConfig};
 
 #[cfg(feature = "pmoserver")]
 pub use openapi::ApiDoc;
 
-#[cfg(feature = "pmoserver")]
-use utoipa::OpenApi;
 #[cfg(feature = "pmoserver")]
 use std::sync::Arc;
+#[cfg(feature = "pmoserver")]
+use utoipa::OpenApi;
 
 /// Générateur de variantes d'images
 ///
@@ -64,7 +64,13 @@ fn create_variant_generator() -> pmocache::pmoserver_ext::ParamGenerator<CoversC
                 match webp::generate_variant(&cache, &pk, size).await {
                     Ok(data) => return Some(data),
                     Err(e) => {
-                        tracing::warn!("Cannot generate variant {}x{} for {}: {}", size, size, pk, e);
+                        tracing::warn!(
+                            "Cannot generate variant {}x{} for {}: {}",
+                            size,
+                            size,
+                            pk,
+                            e
+                        );
                         return None;
                     }
                 }
@@ -98,21 +104,26 @@ pub trait CoverCacheExt {
     /// - `DELETE /api/covers/{pk}` - Supprimer une image (API REST)
     /// - `GET /api/covers/{pk}/status` - Statut du téléchargement
     /// - `GET /swagger-ui/covers` - Documentation interactive
-    async fn init_cover_cache(&mut self, cache_dir: &str, limit: usize)
-        -> anyhow::Result<Arc<Cache>>;
+    async fn init_cover_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> anyhow::Result<Arc<Cache>>;
 
     /// Initialise le cache d'images avec la configuration par défaut
     ///
     /// Utilise automatiquement les paramètres de `pmoconfig::Config`
-    async fn init_cover_cache_configured(&mut self)
-        -> anyhow::Result<Arc<Cache>>;
+    async fn init_cover_cache_configured(&mut self) -> anyhow::Result<Arc<Cache>>;
 }
 
 #[cfg(feature = "pmoserver")]
 impl CoverCacheExt for pmoserver::Server {
-    async fn init_cover_cache(&mut self, cache_dir: &str, limit: usize)
-        -> anyhow::Result<Arc<Cache>> {
-        use pmocache::pmoserver_ext::{create_file_router_with_generator, create_api_router};
+    async fn init_cover_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> anyhow::Result<Arc<Cache>> {
+        use pmocache::pmoserver_ext::{create_api_router, create_file_router_with_generator};
 
         let cache = Arc::new(cache::new_cache(cache_dir, limit)?);
 
@@ -121,7 +132,7 @@ impl CoverCacheExt for pmoserver::Server {
         let file_router = create_file_router_with_generator(
             cache.clone(),
             "image/webp",
-            Some(create_variant_generator())
+            Some(create_variant_generator()),
         );
         self.add_router("/", file_router).await;
 
@@ -134,8 +145,7 @@ impl CoverCacheExt for pmoserver::Server {
         Ok(cache)
     }
 
-    async fn init_cover_cache_configured(&mut self)
-        -> anyhow::Result<Arc<Cache>> {
+    async fn init_cover_cache_configured(&mut self) -> anyhow::Result<Arc<Cache>> {
         let config = pmoconfig::get_config();
         let cache_dir = config.get_cover_cache_dir()?;
         let limit = config.get_cover_cache_size()?;
diff --git a/pmocovers/src/webp.rs b/pmocovers/src/webp.rs
index 0f3fa443..c1a11464 100644
--- a/pmocovers/src/webp.rs
+++ b/pmocovers/src/webp.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use image::{DynamicImage, imageops::FilterType};
+use image::{imageops::FilterType, DynamicImage};
 use webp::{Encoder, WebPMemory};
 
 pub fn encode_webp(img: &DynamicImage) -> Result<Vec<u8>> {
@@ -11,34 +11,38 @@ pub fn encode_webp(img: &DynamicImage) -> Result<Vec<u8>> {
 
 pub fn ensure_square(img: &DynamicImage, size: u32) -> DynamicImage {
     let (width, height) = (img.width(), img.height());
-    
+
     // Calculer le ratio de mise à l'échelle
     let scale = if width > height {
         size as f32 / width as f32
     } else {
         size as f32 / height as f32
     };
-    
+
     let new_width = (width as f32 * scale) as u32;
     let new_height = (height as f32 * scale) as u32;
-    
+
     // Redimensionner l'image
     let resized = img.resize(new_width, new_height, FilterType::Lanczos3);
-    
+
     // Créer une image carrée avec fond transparent
     let mut square = DynamicImage::new_rgba8(size, size);
-    
+
     // Calculer la position pour centrer l'image redimensionnée
     let x = (size - new_width) / 2;
     let y = (size - new_height) / 2;
-    
+
     // Copier l'image redimensionnée au centre du carré
     image::imageops::overlay(&mut square, &resized, x.into(), y.into());
-    
+
     square
 }
 
-pub async fn generate_variant(cache: &super::cache::Cache, pk: &str, size: usize) -> Result<Vec<u8>> {
+pub async fn generate_variant(
+    cache: &super::cache::Cache,
+    pk: &str,
+    size: usize,
+) -> Result<Vec<u8>> {
     // Utiliser file_path_with_qualifier pour obtenir le chemin
     let variant_path = cache.file_path_with_qualifier(pk, &size.to_string());
 
@@ -49,10 +53,7 @@ pub async fn generate_variant(cache: &super::cache::Cache, pk: &str, size: usize
     let orig_path = cache.file_path_with_qualifier(pk, "orig");
 
     // Charger l'image de manière synchrone (image::open n'est pas async)
-    let img = tokio::task::spawn_blocking(move || {
-        image::open(orig_path)
-    })
-    .await??;
+    let img = tokio::task::spawn_blocking(move || image::open(orig_path)).await??;
 
     let square = ensure_square(&img, size as u32);
     let webp_data = encode_webp(&square)?;
diff --git a/pmodidl/src/lib.rs b/pmodidl/src/lib.rs
index 9187ae5d..4058d482 100644
--- a/pmodidl/src/lib.rs
+++ b/pmodidl/src/lib.rs
@@ -2,19 +2,19 @@
 //!
 //! Parser et utilitaires pour le format DIDL-Lite utilisé dans UPnP/DLNA.
 
+use bevy_reflect::Reflect;
 use serde::{Deserialize, Serialize};
 use std::fmt::Write;
-use bevy_reflect::Reflect;
 
 // ============= Couche d'abstraction générique =============
 
 /// Trait pour tout parser de métadonnées média
 pub trait MediaMetadataParser: Sized {
     type Error: std::error::Error + Send + Sync + 'static;
-    
+
     /// Parse une chaîne de métadonnées
     fn parse(input: &str) -> Result<Self, Self::Error>;
-    
+
     /// Retourne le format du parser
     fn format_name() -> &'static str;
 }
@@ -24,10 +24,10 @@ pub trait MediaMetadataParser: Sized {
 pub struct ParsedMetadata<T> {
     /// Format du document (ex: "DIDL-Lite", "RSS", etc.)
     pub format: String,
-    
+
     /// Données parsées
     pub data: T,
-    
+
     /// Timestamp du parsing (exclu de la réflexion car SystemTime n'implémente pas Reflect)
     #[reflect(ignore)]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -42,7 +42,7 @@ impl<T> ParsedMetadata<T> {
             parsed_at: Some(std::time::SystemTime::now()),
         }
     }
-    
+
     /// Transforme les données avec une fonction
     pub fn map<U, F>(self, f: F) -> ParsedMetadata<U>
     where
@@ -66,11 +66,11 @@ pub fn parse_metadata<P: MediaMetadataParser>(input: &str) -> Result<ParsedMetad
 
 impl MediaMetadataParser for DIDLLite {
     type Error = quick_xml::de::DeError;
-    
+
     fn parse(input: &str) -> Result<Self, Self::Error> {
         quick_xml::de::from_str(input)
     }
-    
+
     fn format_name() -> &'static str {
         "DIDL-Lite"
     }
@@ -81,32 +81,31 @@ pub type DidlMetadata = ParsedMetadata<DIDLLite>;
 
 // ============= Structures DIDL-Lite =============
 
-
 /// Racine d'un document DIDL-Lite
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, Reflect)]
 #[serde(rename = "DIDL-Lite")]
 pub struct DIDLLite {
     #[serde(rename = "@xmlns")]
     pub xmlns: String,
-    
+
     #[serde(rename = "@xmlns:upnp", skip_serializing_if = "Option::is_none")]
     pub xmlns_upnp: Option<String>,
-    
+
     #[serde(rename = "@xmlns:dc", skip_serializing_if = "Option::is_none")]
     pub xmlns_dc: Option<String>,
-    
+
     #[serde(rename = "@xmlns:dlna", skip_serializing_if = "Option::is_none")]
     pub xmlns_dlna: Option<String>,
-    
+
     #[serde(rename = "@xmlns:sec", skip_serializing_if = "Option::is_none")]
     pub xmlns_sec: Option<String>,
-    
+
     #[serde(rename = "@xmlns:pv", skip_serializing_if = "Option::is_none")]
     pub xmlns_pv: Option<String>,
-    
+
     #[serde(rename = "container", default)]
     pub containers: Vec<Container>,
-    
+
     #[serde(rename = "item", default)]
     pub items: Vec<Item>,
 }
@@ -116,25 +115,25 @@ pub struct DIDLLite {
 pub struct Container {
     #[serde(rename = "@id")]
     pub id: String,
-    
+
     #[serde(rename = "@parentID")]
     pub parent_id: String,
-    
+
     #[serde(rename = "@restricted", skip_serializing_if = "Option::is_none")]
     pub restricted: Option<String>,
-    
+
     #[serde(rename = "@childCount", skip_serializing_if = "Option::is_none")]
     pub child_count: Option<String>,
-    
+
     #[serde(rename = "dc:title", alias = "title")]
     pub title: String,
-    
+
     #[serde(rename = "upnp:class", alias = "class")]
     pub class: String,
-    
+
     #[serde(rename = "container", default)]
     pub containers: Vec<Container>,
-    
+
     #[serde(rename = "item", default)]
     pub items: Vec<Item>,
 }
@@ -144,46 +143,74 @@ pub struct Container {
 pub struct Item {
     #[serde(rename = "@id")]
     pub id: String,
-    
+
     #[serde(rename = "@parentID")]
     pub parent_id: String,
-    
+
     #[serde(rename = "@restricted", skip_serializing_if = "Option::is_none")]
     pub restricted: Option<String>,
-    
+
     #[serde(rename = "dc:title", alias = "title")]
     pub title: String,
-    
-    #[serde(rename = "dc:creator", alias = "creator", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "dc:creator",
+        alias = "creator",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub creator: Option<String>,
-    
+
     #[serde(rename = "upnp:class", alias = "class")]
     pub class: String,
-    
-    #[serde(rename = "upnp:artist", alias = "artist", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "upnp:artist",
+        alias = "artist",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub artist: Option<String>,
-    
-    #[serde(rename = "upnp:album", alias = "album", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "upnp:album",
+        alias = "album",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub album: Option<String>,
-    
-    #[serde(rename = "upnp:genre", alias = "genre", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "upnp:genre",
+        alias = "genre",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub genre: Option<String>,
-    
-    #[serde(rename = "upnp:albumArtURI", alias = "albumArtURI", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "upnp:albumArtURI",
+        alias = "albumArtURI",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub album_art: Option<String>,
-    
+
     #[serde(skip)]
     pub album_art_pk: Option<String>,
-    
-    #[serde(rename = "dc:date", alias = "date", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "dc:date",
+        alias = "date",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub date: Option<String>,
-    
-    #[serde(rename = "upnp:originalTrackNumber", alias = "originalTrackNumber", skip_serializing_if = "Option::is_none")]
+
+    #[serde(
+        rename = "upnp:originalTrackNumber",
+        alias = "originalTrackNumber",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub original_track_number: Option<String>,
-    
+
     #[serde(rename = "res", default)]
     pub resources: Vec<Resource>,
-    
+
     #[serde(rename = "desc", default)]
     pub descriptions: Vec<Description>,
 }
@@ -193,19 +220,19 @@ pub struct Item {
 pub struct Resource {
     #[serde(rename = "@protocolInfo")]
     pub protocol_info: String,
-    
+
     #[serde(rename = "@bitsPerSample", skip_serializing_if = "Option::is_none")]
     pub bits_per_sample: Option<String>,
-    
+
     #[serde(rename = "@sampleFrequency", skip_serializing_if = "Option::is_none")]
     pub sample_frequency: Option<String>,
-    
+
     #[serde(rename = "@nrAudioChannels", skip_serializing_if = "Option::is_none")]
     pub nr_audio_channels: Option<String>,
-    
+
     #[serde(rename = "@duration", skip_serializing_if = "Option::is_none")]
     pub duration: Option<String>,
-    
+
     #[serde(rename = "$text")]
     pub url: String,
 }
@@ -215,13 +242,13 @@ pub struct Resource {
 pub struct Description {
     #[serde(rename = "@id", skip_serializing_if = "Option::is_none")]
     pub id: Option<String>,
-    
+
     #[serde(rename = "@nameSpace", skip_serializing_if = "Option::is_none")]
     pub namespace: Option<String>,
-    
+
     #[serde(rename = "track_gain", skip_serializing_if = "Option::is_none")]
     pub track_gain: Option<String>,
-    
+
     #[serde(rename = "track_peak", skip_serializing_if = "Option::is_none")]
     pub track_peak: Option<String>,
 }
@@ -233,22 +260,22 @@ impl DIDLLite {
     pub fn all_containers(&self) -> impl Iterator<Item = &Container> {
         AllContainersIter::new(&self.containers)
     }
-    
+
     /// Itère sur tous les items de manière récursive
     pub fn all_items(&self) -> impl Iterator<Item = &Item> {
         AllItemsIter::new(&self.containers, &self.items)
     }
-    
+
     /// Trouve un container par ID
     pub fn get_container_by_id(&self, id: &str) -> Option<&Container> {
         self.all_containers().find(|c| c.id == id)
     }
-    
+
     /// Trouve un item par ID
     pub fn get_item_by_id(&self, id: &str) -> Option<&Item> {
         self.all_items().find(|i| i.id == id)
     }
-    
+
     /// Filtre les containers
     pub fn filter_containers<F>(&self, predicate: F) -> impl Iterator<Item = &Container>
     where
@@ -256,7 +283,7 @@ impl DIDLLite {
     {
         self.all_containers().filter(move |c| predicate(c))
     }
-    
+
     /// Filtre les items
     pub fn filter_items<F>(&self, predicate: F) -> impl Iterator<Item = &Item>
     where
@@ -264,26 +291,26 @@ impl DIDLLite {
     {
         self.all_items().filter(move |i| predicate(i))
     }
-    
+
     /// Génère une représentation Markdown
     pub fn to_markdown(&self) -> String {
         let mut buf = String::new();
         buf.push_str("### DIDL-Lite Document\n\n");
-        
+
         if !self.containers.is_empty() {
             buf.push_str("#### Containers\n\n");
             for container in &self.containers {
                 container.write_markdown(&mut buf, 0);
             }
         }
-        
+
         if !self.items.is_empty() {
             buf.push_str("#### Items\n\n");
             for item in &self.items {
                 item.write_markdown(&mut buf, 0);
             }
         }
-        
+
         buf
     }
 }
@@ -293,41 +320,41 @@ impl Container {
     pub fn all_containers(&self) -> impl Iterator<Item = &Container> {
         AllContainersIter::new(&self.containers)
     }
-    
+
     /// Itère sur tous les items de ce container et ses enfants
     pub fn all_items(&self) -> impl Iterator<Item = &Item> {
         AllItemsIter::new(&self.containers, &self.items)
     }
-    
+
     fn write_markdown(&self, buf: &mut String, depth: usize) {
         let indent = "  ".repeat(depth);
-        
+
         writeln!(buf, "{}- **Container**: {}", indent, self.title).unwrap();
         writeln!(buf, "{}  - ID: `{}`", indent, self.id).unwrap();
         writeln!(buf, "{}  - ParentID: `{}`", indent, self.parent_id).unwrap();
         writeln!(buf, "{}  - Class: `{}`", indent, self.class).unwrap();
-        
+
         if let Some(ref restricted) = self.restricted {
             writeln!(buf, "{}  - Restricted: `{}`", indent, restricted).unwrap();
         }
         if let Some(ref count) = self.child_count {
             writeln!(buf, "{}  - ChildCount: `{}`", indent, count).unwrap();
         }
-        
+
         if !self.containers.is_empty() {
             writeln!(buf, "{}  - Subcontainers:", indent).unwrap();
             for sub in &self.containers {
                 sub.write_markdown(buf, depth + 2);
             }
         }
-        
+
         if !self.items.is_empty() {
             writeln!(buf, "{}  - Items:", indent).unwrap();
             for item in &self.items {
                 item.write_markdown(buf, depth + 2);
             }
         }
-        
+
         buf.push('\n');
     }
 }
@@ -335,21 +362,22 @@ impl Container {
 impl Item {
     /// Itère sur les ressources audio uniquement
     pub fn audio_resources(&self) -> impl Iterator<Item = &Resource> {
-        self.resources.iter()
+        self.resources
+            .iter()
             .filter(|r| r.protocol_info.contains("audio/"))
     }
-    
+
     /// Retourne la ressource principale (première disponible)
     pub fn primary_resource(&self) -> Option<&Resource> {
         self.resources.first()
     }
-    
+
     /// Itère sur les métadonnées sous forme de paires clé-valeur
     pub fn metadata(&self) -> impl Iterator<Item = (&str, &str)> {
         let mut pairs = Vec::new();
-        
+
         pairs.push(("title", self.title.as_str()));
-        
+
         if let Some(ref artist) = self.artist {
             pairs.push(("artist", artist.as_str()));
         }
@@ -365,7 +393,7 @@ impl Item {
         if let Some(ref track) = self.original_track_number {
             pairs.push(("trackNumber", track.as_str()));
         }
-        
+
         for desc in &self.descriptions {
             if let Some(ref gain) = desc.track_gain {
                 pairs.push(("replayGain", gain.as_str()));
@@ -374,18 +402,18 @@ impl Item {
                 pairs.push(("replayPeak", peak.as_str()));
             }
         }
-        
+
         pairs.into_iter()
     }
-    
+
     fn write_markdown(&self, buf: &mut String, depth: usize) {
         let indent = "  ".repeat(depth);
-        
+
         writeln!(buf, "{}- **Item**: {}", indent, self.title).unwrap();
         writeln!(buf, "{}  - ID: `{}`", indent, self.id).unwrap();
         writeln!(buf, "{}  - ParentID: `{}`", indent, self.parent_id).unwrap();
         writeln!(buf, "{}  - Class: `{}`", indent, self.class).unwrap();
-        
+
         if let Some(ref creator) = self.creator {
             writeln!(buf, "{}  - Creator: {}", indent, creator).unwrap();
         }
@@ -407,7 +435,7 @@ impl Item {
         if let Some(ref track) = self.original_track_number {
             writeln!(buf, "{}  - Track: {}", indent, track).unwrap();
         }
-        
+
         if !self.resources.is_empty() {
             writeln!(buf, "{}  - Resources:", indent).unwrap();
             for res in &self.resources {
@@ -427,7 +455,7 @@ impl Item {
                 }
             }
         }
-        
+
         if !self.descriptions.is_empty() {
             writeln!(buf, "{}  - Descriptions:", indent).unwrap();
             for desc in &self.descriptions {
@@ -442,7 +470,7 @@ impl Item {
                 }
             }
         }
-        
+
         buf.push('\n');
     }
 }
@@ -463,7 +491,7 @@ impl<'a> AllContainersIter<'a> {
 
 impl<'a> Iterator for AllContainersIter<'a> {
     type Item = &'a Container;
-    
+
     fn next(&mut self) -> Option<Self::Item> {
         self.stack.pop().map(|container| {
             // Ajouter les enfants à la pile
@@ -489,13 +517,13 @@ impl<'a> AllItemsIter<'a> {
 
 impl<'a> Iterator for AllItemsIter<'a> {
     type Item = &'a Item;
-    
+
     fn next(&mut self) -> Option<Self::Item> {
         loop {
             if let Some(item) = self.current_items.next() {
                 return Some(item);
             }
-            
+
             let container = self.containers.pop()?;
             self.containers.extend(container.containers.iter());
             self.current_items = container.items.iter();
@@ -506,7 +534,7 @@ impl<'a> Iterator for AllItemsIter<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_parse_simple_didl() {
         let xml = r#"
@@ -520,12 +548,12 @@ mod tests {
             </item>
         </DIDL-Lite>
         "#;
-        
+
         let didl = DIDLLite::parse(xml).unwrap();
         assert_eq!(didl.items.len(), 1);
         assert_eq!(didl.items[0].title, "Test Song");
     }
-    
+
     #[test]
     fn test_parse_without_namespaces() {
         // Teste un XML sans namespaces explicites (devices UPnP laxistes)
@@ -538,12 +566,12 @@ mod tests {
             </item>
         </DIDL-Lite>
         "#;
-        
+
         let didl = DIDLLite::parse(xml).unwrap();
         assert_eq!(didl.items.len(), 1);
         assert_eq!(didl.items[0].title, "Test Song");
     }
-    
+
     #[test]
     fn test_generic_parser() {
         let xml = r#"
@@ -552,14 +580,14 @@ mod tests {
                    xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">
         </DIDL-Lite>
         "#;
-        
+
         // Utiliser le parser générique
         let metadata: DidlMetadata = parse_metadata(xml).unwrap();
-        
+
         assert_eq!(metadata.format, "DIDL-Lite");
         assert!(metadata.parsed_at.is_some());
     }
-    
+
     #[test]
     fn test_metadata_map() {
         let xml = r#"
@@ -568,13 +596,13 @@ mod tests {
                    xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">
         </DIDL-Lite>
         "#;
-        
+
         let metadata: DidlMetadata = parse_metadata(xml).unwrap();
-        
+
         // Transformer les données
         let item_count = metadata.map(|didl| didl.items.len());
-        
+
         assert_eq!(item_count.format, "DIDL-Lite");
         assert_eq!(item_count.data, 0);
     }
-}
\ No newline at end of file
+}
diff --git a/pmomediarenderer/src/avtransport/actions/getmediainfo.rs b/pmomediarenderer/src/avtransport/actions/getmediainfo.rs
index 2ead4422..ffed1d49 100644
--- a/pmomediarenderer/src/avtransport/actions/getmediainfo.rs
+++ b/pmomediarenderer/src/avtransport/actions/getmediainfo.rs
@@ -1,4 +1,7 @@
-use crate::avtransport::variables::{A_ARG_TYPE_INSTANCE_ID, NUMBEROFTRACKS, CURRENTTRACK, AVTRANSPORTURI, AVTRANSPORTURIMETADATA, AVTRANSPORTNEXTURI, AVTRANSPORTNEXTURIMETADATA};
+use crate::avtransport::variables::{
+    A_ARG_TYPE_INSTANCE_ID, AVTRANSPORTNEXTURI, AVTRANSPORTNEXTURIMETADATA, AVTRANSPORTURI,
+    AVTRANSPORTURIMETADATA, CURRENTTRACK, NUMBEROFTRACKS,
+};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/avtransport/actions/getpositioninfo.rs b/pmomediarenderer/src/avtransport/actions/getpositioninfo.rs
index b806730a..c7ac9263 100644
--- a/pmomediarenderer/src/avtransport/actions/getpositioninfo.rs
+++ b/pmomediarenderer/src/avtransport/actions/getpositioninfo.rs
@@ -1,4 +1,7 @@
-use crate::avtransport::variables::{A_ARG_TYPE_INSTANCE_ID, CURRENTTRACK, CURRENTTRACKDURATION, AVTRANSPORTURI, AVTRANSPORTURIMETADATA, RELATIVETIMEPOSITION, ABSOLUTETIMEPOSITION};
+use crate::avtransport::variables::{
+    A_ARG_TYPE_INSTANCE_ID, ABSOLUTETIMEPOSITION, AVTRANSPORTURI, AVTRANSPORTURIMETADATA,
+    CURRENTTRACK, CURRENTTRACKDURATION, RELATIVETIMEPOSITION,
+};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/avtransport/actions/mod.rs b/pmomediarenderer/src/avtransport/actions/mod.rs
index 9b0ad316..91bf8757 100644
--- a/pmomediarenderer/src/avtransport/actions/mod.rs
+++ b/pmomediarenderer/src/avtransport/actions/mod.rs
@@ -27,4 +27,3 @@ pub use seek::SEEK;
 pub use setavtransportnexturi::SETNEXTAVTRANSPORTURI;
 pub use setavtransporturi::SETAVTRANSPORTURI;
 pub use stop::STOP;
-
diff --git a/pmomediarenderer/src/avtransport/actions/play.rs b/pmomediarenderer/src/avtransport/actions/play.rs
index 260ec23d..c07900c5 100644
--- a/pmomediarenderer/src/avtransport/actions/play.rs
+++ b/pmomediarenderer/src/avtransport/actions/play.rs
@@ -1,6 +1,6 @@
 use crate::avtransport::variables::{A_ARG_TYPE_INSTANCE_ID, TRANSPORTPLAYSPEED};
 use pmoupnp::define_action;
- 
+
 define_action! {
     pub static PLAY = "Play" {
         in "InstanceID" => A_ARG_TYPE_INSTANCE_ID,
diff --git a/pmomediarenderer/src/avtransport/actions/seek.rs b/pmomediarenderer/src/avtransport/actions/seek.rs
index 96cd488c..24a8111d 100644
--- a/pmomediarenderer/src/avtransport/actions/seek.rs
+++ b/pmomediarenderer/src/avtransport/actions/seek.rs
@@ -1,4 +1,6 @@
-use crate::avtransport::variables::{A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_SEEKMODE, CURRENTTRACKDURATION};
+use crate::avtransport::variables::{
+    A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_SEEKMODE, CURRENTTRACKDURATION,
+};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/avtransport/actions/setavtransportnexturi.rs b/pmomediarenderer/src/avtransport/actions/setavtransportnexturi.rs
index 5a7459f9..94df0c87 100644
--- a/pmomediarenderer/src/avtransport/actions/setavtransportnexturi.rs
+++ b/pmomediarenderer/src/avtransport/actions/setavtransportnexturi.rs
@@ -1,4 +1,6 @@
-use crate::avtransport::variables::{A_ARG_TYPE_INSTANCE_ID, AVTRANSPORTNEXTURI, AVTRANSPORTNEXTURIMETADATA};
+use crate::avtransport::variables::{
+    A_ARG_TYPE_INSTANCE_ID, AVTRANSPORTNEXTURI, AVTRANSPORTNEXTURIMETADATA,
+};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/avtransport/actions/setavtransporturi.rs b/pmomediarenderer/src/avtransport/actions/setavtransporturi.rs
index c4fbd929..44e77da4 100644
--- a/pmomediarenderer/src/avtransport/actions/setavtransporturi.rs
+++ b/pmomediarenderer/src/avtransport/actions/setavtransporturi.rs
@@ -1,4 +1,6 @@
-use crate::avtransport::variables::{A_ARG_TYPE_INSTANCE_ID, AVTRANSPORTURI, AVTRANSPORTURIMETADATA};
+use crate::avtransport::variables::{
+    A_ARG_TYPE_INSTANCE_ID, AVTRANSPORTURI, AVTRANSPORTURIMETADATA,
+};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/avtransport/mod.rs b/pmomediarenderer/src/avtransport/mod.rs
index 4ad811ed..d685ce52 100644
--- a/pmomediarenderer/src/avtransport/mod.rs
+++ b/pmomediarenderer/src/avtransport/mod.rs
@@ -91,22 +91,21 @@
 
 use pmoupnp::define_service;
 
-pub mod variables;
 pub mod actions;
+pub mod variables;
 
 use actions::{
-    GETCURRENTTRANSPORTACTIONS, GETDEVICECAPABILITIES, GETMEDIAINFO,
-    GETPOSITIONINFO, GETTRANSPORTINFO, GETTRANSPORTSETTINGS, NEXT, PAUSE,
-    PLAY, PREVIOUS, SEEK, SETNEXTAVTRANSPORTURI, SETAVTRANSPORTURI, STOP
+    GETCURRENTTRANSPORTACTIONS, GETDEVICECAPABILITIES, GETMEDIAINFO, GETPOSITIONINFO,
+    GETTRANSPORTINFO, GETTRANSPORTSETTINGS, NEXT, PAUSE, PLAY, PREVIOUS, SEEK, SETAVTRANSPORTURI,
+    SETNEXTAVTRANSPORTURI, STOP,
 };
 use variables::{
-    ABSOLUTETIMEPOSITION, AVTRANSPORTNEXTURI, AVTRANSPORTNEXTURIMETADATA,
-    AVTRANSPORTURI, AVTRANSPORTURIMETADATA, A_ARG_TYPE_INSTANCE_ID,
-    A_ARG_TYPE_PLAY_SPEED, A_ARG_TYPE_SEEKMODE, CURRENTMEDIADURATION,
-    CURRENTPLAYMODE, CURRENTTRACK, CURRENTTRACKDURATION, CURRENTTRACKMETADATA,
-    CURRENTTRACKURI, NUMBEROFTRACKS, PLAYBACKSTORAGEMEDIUM,
-    POSSIBLEPLAYBACKSTORAGEMEDIA, RELATIVETIMEPOSITION, SEEKMODE,
-    TRANSPORTPLAYSPEED, TRANSPORTSTATE, TRANSPORTSTATUS
+    A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_PLAY_SPEED, A_ARG_TYPE_SEEKMODE, ABSOLUTETIMEPOSITION,
+    AVTRANSPORTNEXTURI, AVTRANSPORTNEXTURIMETADATA, AVTRANSPORTURI, AVTRANSPORTURIMETADATA,
+    CURRENTMEDIADURATION, CURRENTPLAYMODE, CURRENTTRACK, CURRENTTRACKDURATION,
+    CURRENTTRACKMETADATA, CURRENTTRACKURI, NUMBEROFTRACKS, PLAYBACKSTORAGEMEDIUM,
+    POSSIBLEPLAYBACKSTORAGEMEDIA, RELATIVETIMEPOSITION, SEEKMODE, TRANSPORTPLAYSPEED,
+    TRANSPORTSTATE, TRANSPORTSTATUS,
 };
 
 // Service AVTransport:1 conforme à la spécification UPnP AV pour MediaRenderer audio
@@ -154,4 +153,4 @@ define_service! {
             STOP,
         ]
     }
-}
\ No newline at end of file
+}
diff --git a/pmomediarenderer/src/avtransport/variables/avtransporturimetadata.rs b/pmomediarenderer/src/avtransport/variables/avtransporturimetadata.rs
index 41f6489a..9f6d4b93 100644
--- a/pmomediarenderer/src/avtransport/variables/avtransporturimetadata.rs
+++ b/pmomediarenderer/src/avtransport/variables/avtransporturimetadata.rs
@@ -1,31 +1,37 @@
 use std::sync::Arc;
 
-use pmoupnp::state_variables::{StateVariable, StateVariableError};
-use pmoupnp::variable_types::StateVarType;
 use bevy_reflect::Reflect;
 use once_cell::sync::Lazy;
 use pmodidl::{DIDLLite, MediaMetadataParser};
-
+use pmoupnp::state_variables::{StateVariable, StateVariableError};
+use pmoupnp::variable_types::StateVarType;
 
 fn avtransporturimetadataparser(value: &str) -> Result<Box<dyn Reflect>, StateVariableError> {
     // Parse DIDL-Lite
     let didl = DIDLLite::parse(value)
         .map_err(|e| StateVariableError::ParseError(format!("Failed to parse DIDL-Lite: {}", e)))?;
-    
+
     // Retourne le résultat sous forme de Box<dyn Reflect>
     Ok(Box::new(didl) as Box<dyn Reflect>)
 }
 
-pub static AVTRANSPORTURIMETADATA: Lazy<Arc<StateVariable>> = Lazy::new(|| -> Arc<StateVariable> {
-    let mut sv = StateVariable::new(StateVarType::String, "AVTransportURIMetaData".to_string());
+pub static AVTRANSPORTURIMETADATA: Lazy<Arc<StateVariable>> =
+    Lazy::new(|| -> Arc<StateVariable> {
+        let mut sv = StateVariable::new(StateVarType::String, "AVTransportURIMetaData".to_string());
 
-    sv.set_value_parser(Arc::new(avtransporturimetadataparser)).expect("Failed to set parser");
-    Arc::new(sv)
-});
+        sv.set_value_parser(Arc::new(avtransporturimetadataparser))
+            .expect("Failed to set parser");
+        Arc::new(sv)
+    });
 
-pub static AVTRANSPORTNEXTURIMETADATA: Lazy<Arc<StateVariable>> = Lazy::new(|| -> Arc<StateVariable> {
-    let mut sv = StateVariable::new(StateVarType::String, "AVTransportNextURIMetaData".to_string());
+pub static AVTRANSPORTNEXTURIMETADATA: Lazy<Arc<StateVariable>> =
+    Lazy::new(|| -> Arc<StateVariable> {
+        let mut sv = StateVariable::new(
+            StateVarType::String,
+            "AVTransportNextURIMetaData".to_string(),
+        );
 
-    sv.set_value_parser(Arc::new(avtransporturimetadataparser)).expect("Failed to set parser");
-    Arc::new(sv)
-});
+        sv.set_value_parser(Arc::new(avtransporturimetadataparser))
+            .expect("Failed to set parser");
+        Arc::new(sv)
+    });
diff --git a/pmomediarenderer/src/avtransport/variables/mod.rs b/pmomediarenderer/src/avtransport/variables/mod.rs
index 00cf43fd..161ab4d0 100644
--- a/pmomediarenderer/src/avtransport/variables/mod.rs
+++ b/pmomediarenderer/src/avtransport/variables/mod.rs
@@ -21,10 +21,10 @@ mod transportstatus;
 pub use a_arg_type_instanceid::A_ARG_TYPE_INSTANCE_ID;
 pub use a_arg_type_playspeed::A_ARG_TYPE_PLAY_SPEED;
 pub use a_arg_type_seekmode::A_ARG_TYPE_SEEKMODE;
-pub use avtransporturi::AVTRANSPORTURI;
 pub use avtransporturi::AVTRANSPORTNEXTURI;
-pub use avtransporturimetadata::AVTRANSPORTURIMETADATA;
+pub use avtransporturi::AVTRANSPORTURI;
 pub use avtransporturimetadata::AVTRANSPORTNEXTURIMETADATA;
+pub use avtransporturimetadata::AVTRANSPORTURIMETADATA;
 pub use currentmediaduration::CURRENTMEDIADURATION;
 pub use currentplaymode::CURRENTPLAYMODE;
 pub use currenttrackmetadata::CURRENTTRACKMETADATA;
@@ -42,6 +42,3 @@ pub use trackduration::RELATIVETIMEPOSITION;
 pub use transportplayspeed::TRANSPORTPLAYSPEED;
 pub use transportstate::TRANSPORTSTATE;
 pub use transportstatus::TRANSPORTSTATUS;
-
-
-
diff --git a/pmomediarenderer/src/avtransport/variables/possiblerecordstoragemedia.rs b/pmomediarenderer/src/avtransport/variables/possiblerecordstoragemedia.rs
index f310324f..49da1a16 100644
--- a/pmomediarenderer/src/avtransport/variables/possiblerecordstoragemedia.rs
+++ b/pmomediarenderer/src/avtransport/variables/possiblerecordstoragemedia.rs
@@ -1,10 +1,14 @@
 use std::sync::Arc;
 
+use once_cell::sync::Lazy;
 use pmoupnp::state_variables::StateVariable;
 use pmoupnp::variable_types::StateVarType;
-use once_cell::sync::Lazy;
 
-pub static POSSIBLERECORDSTORAGEMEDIA: Lazy<Arc<StateVariable>> = Lazy::new(|| -> Arc<StateVariable> {
-    let sv = StateVariable::new(StateVarType::String, "PossibleRecordStorageMedia".to_string());
-    Arc::new(sv)
-});
+pub static POSSIBLERECORDSTORAGEMEDIA: Lazy<Arc<StateVariable>> =
+    Lazy::new(|| -> Arc<StateVariable> {
+        let sv = StateVariable::new(
+            StateVarType::String,
+            "PossibleRecordStorageMedia".to_string(),
+        );
+        Arc::new(sv)
+    });
diff --git a/pmomediarenderer/src/avtransport/variables/recordstoragemedium.rs b/pmomediarenderer/src/avtransport/variables/recordstoragemedium.rs
index 3805352e..460b198a 100644
--- a/pmomediarenderer/src/avtransport/variables/recordstoragemedium.rs
+++ b/pmomediarenderer/src/avtransport/variables/recordstoragemedium.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
+use once_cell::sync::Lazy;
 use pmoupnp::state_variables::StateVariable;
 use pmoupnp::variable_types::StateVarType;
-use once_cell::sync::Lazy;
 
 pub static RECORDSTORAGEMEDIUM: Lazy<Arc<StateVariable>> = Lazy::new(|| -> Arc<StateVariable> {
     let sv = StateVariable::new(StateVarType::String, "RecordStorageMedium".to_string());
diff --git a/pmomediarenderer/src/avtransport/variables/seekmode.rs b/pmomediarenderer/src/avtransport/variables/seekmode.rs
index 6e99d634..60925bd6 100644
--- a/pmomediarenderer/src/avtransport/variables/seekmode.rs
+++ b/pmomediarenderer/src/avtransport/variables/seekmode.rs
@@ -3,4 +3,3 @@ use pmoupnp::define_variable;
 define_variable! {
     pub static SEEKMODE: String = "SeekMode"
 }
-
diff --git a/pmomediarenderer/src/avtransport/variables/track.rs b/pmomediarenderer/src/avtransport/variables/track.rs
index 60d99cb2..5587763c 100644
--- a/pmomediarenderer/src/avtransport/variables/track.rs
+++ b/pmomediarenderer/src/avtransport/variables/track.rs
@@ -11,4 +11,3 @@ define_variable! {
         evented: true,
     }
 }
-
diff --git a/pmomediarenderer/src/avtransport/variables/trackduration.rs b/pmomediarenderer/src/avtransport/variables/trackduration.rs
index 1e68b046..af25eb7d 100644
--- a/pmomediarenderer/src/avtransport/variables/trackduration.rs
+++ b/pmomediarenderer/src/avtransport/variables/trackduration.rs
@@ -17,4 +17,3 @@ define_variable! {
         evented: true,
     }
 }
-
diff --git a/pmomediarenderer/src/avtransport/variables/transportplayspeed.rs b/pmomediarenderer/src/avtransport/variables/transportplayspeed.rs
index e0630273..f503a877 100644
--- a/pmomediarenderer/src/avtransport/variables/transportplayspeed.rs
+++ b/pmomediarenderer/src/avtransport/variables/transportplayspeed.rs
@@ -6,4 +6,3 @@ define_variable! {
         default: "1",
     }
 }
-
diff --git a/pmomediarenderer/src/avtransport/variables/transportstate.rs b/pmomediarenderer/src/avtransport/variables/transportstate.rs
index 28b9f5c7..1f1501aa 100644
--- a/pmomediarenderer/src/avtransport/variables/transportstate.rs
+++ b/pmomediarenderer/src/avtransport/variables/transportstate.rs
@@ -7,4 +7,3 @@ define_variable! {
         evented: true,
     }
 }
-
diff --git a/pmomediarenderer/src/connectionmanager/actions/getcurrentconnectioninfo.rs b/pmomediarenderer/src/connectionmanager/actions/getcurrentconnectioninfo.rs
index 1c4353c7..41567ec9 100644
--- a/pmomediarenderer/src/connectionmanager/actions/getcurrentconnectioninfo.rs
+++ b/pmomediarenderer/src/connectionmanager/actions/getcurrentconnectioninfo.rs
@@ -1,6 +1,6 @@
 use crate::connectionmanager::variables::{
-    A_ARG_TYPE_CONNECTIONID, A_ARG_TYPE_RCSID, A_ARG_TYPE_AVTRANSPORTID,
-    A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_DIRECTION, A_ARG_TYPE_CONNECTIONSTATUS
+    A_ARG_TYPE_AVTRANSPORTID, A_ARG_TYPE_CONNECTIONID, A_ARG_TYPE_CONNECTIONSTATUS,
+    A_ARG_TYPE_DIRECTION, A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_RCSID,
 };
 use pmoupnp::define_action;
 
diff --git a/pmomediarenderer/src/connectionmanager/actions/getprotocolinfo.rs b/pmomediarenderer/src/connectionmanager/actions/getprotocolinfo.rs
index c9370ded..2fee1ea6 100644
--- a/pmomediarenderer/src/connectionmanager/actions/getprotocolinfo.rs
+++ b/pmomediarenderer/src/connectionmanager/actions/getprotocolinfo.rs
@@ -1,4 +1,4 @@
-use crate::connectionmanager::variables::{SOURCEPROTOCOLINFO, SINKPROTOCOLINFO};
+use crate::connectionmanager::variables::{SINKPROTOCOLINFO, SOURCEPROTOCOLINFO};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/connectionmanager/actions/mod.rs b/pmomediarenderer/src/connectionmanager/actions/mod.rs
index b9ccd37b..758e55ce 100644
--- a/pmomediarenderer/src/connectionmanager/actions/mod.rs
+++ b/pmomediarenderer/src/connectionmanager/actions/mod.rs
@@ -1,7 +1,7 @@
-mod getprotocolinfo;
 mod getcurrentconnectionids;
 mod getcurrentconnectioninfo;
+mod getprotocolinfo;
 
-pub use getprotocolinfo::GETPROTOCOLINFO;
 pub use getcurrentconnectionids::GETCURRENTCONNECTIONIDS;
 pub use getcurrentconnectioninfo::GETCURRENTCONNECTIONINFO;
+pub use getprotocolinfo::GETPROTOCOLINFO;
diff --git a/pmomediarenderer/src/connectionmanager/mod.rs b/pmomediarenderer/src/connectionmanager/mod.rs
index a5fa9daa..e1f99fd0 100644
--- a/pmomediarenderer/src/connectionmanager/mod.rs
+++ b/pmomediarenderer/src/connectionmanager/mod.rs
@@ -55,14 +55,14 @@
 
 use pmoupnp::define_service;
 
-pub mod variables;
 pub mod actions;
+pub mod variables;
 
 use actions::{GETCURRENTCONNECTIONIDS, GETCURRENTCONNECTIONINFO, GETPROTOCOLINFO};
 use variables::{
     A_ARG_TYPE_AVTRANSPORTID, A_ARG_TYPE_CONNECTIONID, A_ARG_TYPE_CONNECTIONSTATUS,
-    A_ARG_TYPE_DIRECTION, A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_RCSID,
-    CURRENTCONNECTIONIDS, SINKPROTOCOLINFO, SOURCEPROTOCOLINFO
+    A_ARG_TYPE_DIRECTION, A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_RCSID, CURRENTCONNECTIONIDS,
+    SINKPROTOCOLINFO, SOURCEPROTOCOLINFO,
 };
 
 // Service ConnectionManager:1 conforme à la spécification UPnP AV pour MediaRenderer audio
diff --git a/pmomediarenderer/src/connectionmanager/variables/mod.rs b/pmomediarenderer/src/connectionmanager/variables/mod.rs
index 4bc47ea4..e833da0a 100644
--- a/pmomediarenderer/src/connectionmanager/variables/mod.rs
+++ b/pmomediarenderer/src/connectionmanager/variables/mod.rs
@@ -1,19 +1,19 @@
-mod sourceprotocolinfo;
-mod sinkprotocolinfo;
-mod currentconnectionids;
+mod a_arg_type_avtransportid;
 mod a_arg_type_connectionid;
 mod a_arg_type_connectionstatus;
 mod a_arg_type_direction;
 mod a_arg_type_protocolinfo;
 mod a_arg_type_rcsid;
-mod a_arg_type_avtransportid;
+mod currentconnectionids;
+mod sinkprotocolinfo;
+mod sourceprotocolinfo;
 
-pub use sourceprotocolinfo::SOURCEPROTOCOLINFO;
-pub use sinkprotocolinfo::SINKPROTOCOLINFO;
-pub use currentconnectionids::CURRENTCONNECTIONIDS;
+pub use a_arg_type_avtransportid::A_ARG_TYPE_AVTRANSPORTID;
 pub use a_arg_type_connectionid::A_ARG_TYPE_CONNECTIONID;
 pub use a_arg_type_connectionstatus::A_ARG_TYPE_CONNECTIONSTATUS;
 pub use a_arg_type_direction::A_ARG_TYPE_DIRECTION;
 pub use a_arg_type_protocolinfo::A_ARG_TYPE_PROTOCOLINFO;
 pub use a_arg_type_rcsid::A_ARG_TYPE_RCSID;
-pub use a_arg_type_avtransportid::A_ARG_TYPE_AVTRANSPORTID;
+pub use currentconnectionids::CURRENTCONNECTIONIDS;
+pub use sinkprotocolinfo::SINKPROTOCOLINFO;
+pub use sourceprotocolinfo::SOURCEPROTOCOLINFO;
diff --git a/pmomediarenderer/src/device.rs b/pmomediarenderer/src/device.rs
index b8c9df46..2d30d4c2 100644
--- a/pmomediarenderer/src/device.rs
+++ b/pmomediarenderer/src/device.rs
@@ -3,12 +3,11 @@
 use once_cell::sync::Lazy;
 use std::sync::Arc;
 
-use pmoupnp::devices::Device;
 use crate::{
-    avtransport::AVTTRANSPORT,
+    avtransport::AVTTRANSPORT, connectionmanager::CONNECTIONMANAGER,
     renderingcontrol::RENDERINGCONTROL,
-    connectionmanager::CONNECTIONMANAGER,
 };
+use pmoupnp::devices::Device;
 
 /// Device MediaRenderer UPnP.
 ///
@@ -54,13 +53,16 @@ pub static MEDIA_RENDERER: Lazy<Arc<Device>> = Lazy::new(|| {
     device.set_udn_prefix("pmomusic".to_string());
 
     // Ajouter les trois services obligatoires
-    device.add_service(Arc::clone(&AVTTRANSPORT))
+    device
+        .add_service(Arc::clone(&AVTTRANSPORT))
         .expect("Failed to add AVTransport service");
 
-    device.add_service(Arc::clone(&RENDERINGCONTROL))
+    device
+        .add_service(Arc::clone(&RENDERINGCONTROL))
         .expect("Failed to add RenderingControl service");
 
-    device.add_service(Arc::clone(&CONNECTIONMANAGER))
+    device
+        .add_service(Arc::clone(&CONNECTIONMANAGER))
         .expect("Failed to add ConnectionManager service");
 
     Arc::new(device)
diff --git a/pmomediarenderer/src/lib.rs b/pmomediarenderer/src/lib.rs
index 2fc7e45d..308ef1dd 100644
--- a/pmomediarenderer/src/lib.rs
+++ b/pmomediarenderer/src/lib.rs
@@ -29,7 +29,7 @@
 
 pub mod avtransport;
 pub mod connectionmanager;
-pub mod renderingcontrol;
 pub mod device;
+pub mod renderingcontrol;
 
 pub use device::MEDIA_RENDERER;
diff --git a/pmomediarenderer/src/renderingcontrol/actions/getmute.rs b/pmomediarenderer/src/renderingcontrol/actions/getmute.rs
index 729fb127..10ff58a2 100644
--- a/pmomediarenderer/src/renderingcontrol/actions/getmute.rs
+++ b/pmomediarenderer/src/renderingcontrol/actions/getmute.rs
@@ -1,4 +1,4 @@
-use crate::renderingcontrol::variables::{A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_CHANNEL, MUTE};
+use crate::renderingcontrol::variables::{A_ARG_TYPE_CHANNEL, A_ARG_TYPE_INSTANCE_ID, MUTE};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/renderingcontrol/actions/getvolume.rs b/pmomediarenderer/src/renderingcontrol/actions/getvolume.rs
index b5d1d482..7945af33 100644
--- a/pmomediarenderer/src/renderingcontrol/actions/getvolume.rs
+++ b/pmomediarenderer/src/renderingcontrol/actions/getvolume.rs
@@ -1,4 +1,4 @@
-use crate::renderingcontrol::variables::{A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_CHANNEL, VOLUME};
+use crate::renderingcontrol::variables::{A_ARG_TYPE_CHANNEL, A_ARG_TYPE_INSTANCE_ID, VOLUME};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/renderingcontrol/actions/mod.rs b/pmomediarenderer/src/renderingcontrol/actions/mod.rs
index b7998a94..9efb39de 100644
--- a/pmomediarenderer/src/renderingcontrol/actions/mod.rs
+++ b/pmomediarenderer/src/renderingcontrol/actions/mod.rs
@@ -1,9 +1,9 @@
-mod getvolume;
-mod setvolume;
 mod getmute;
+mod getvolume;
 mod setmute;
+mod setvolume;
 
-pub use getvolume::GETVOLUME;
-pub use setvolume::SETVOLUME;
 pub use getmute::GETMUTE;
+pub use getvolume::GETVOLUME;
 pub use setmute::SETMUTE;
+pub use setvolume::SETVOLUME;
diff --git a/pmomediarenderer/src/renderingcontrol/actions/setmute.rs b/pmomediarenderer/src/renderingcontrol/actions/setmute.rs
index fa8ebf5c..8e9a568d 100644
--- a/pmomediarenderer/src/renderingcontrol/actions/setmute.rs
+++ b/pmomediarenderer/src/renderingcontrol/actions/setmute.rs
@@ -1,4 +1,4 @@
-use crate::renderingcontrol::variables::{A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_CHANNEL, MUTE};
+use crate::renderingcontrol::variables::{A_ARG_TYPE_CHANNEL, A_ARG_TYPE_INSTANCE_ID, MUTE};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/renderingcontrol/actions/setvolume.rs b/pmomediarenderer/src/renderingcontrol/actions/setvolume.rs
index 0744e133..33138d9a 100644
--- a/pmomediarenderer/src/renderingcontrol/actions/setvolume.rs
+++ b/pmomediarenderer/src/renderingcontrol/actions/setvolume.rs
@@ -1,4 +1,4 @@
-use crate::renderingcontrol::variables::{A_ARG_TYPE_INSTANCE_ID, A_ARG_TYPE_CHANNEL, VOLUME};
+use crate::renderingcontrol::variables::{A_ARG_TYPE_CHANNEL, A_ARG_TYPE_INSTANCE_ID, VOLUME};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediarenderer/src/renderingcontrol/mod.rs b/pmomediarenderer/src/renderingcontrol/mod.rs
index cf74df9f..1501f0ef 100644
--- a/pmomediarenderer/src/renderingcontrol/mod.rs
+++ b/pmomediarenderer/src/renderingcontrol/mod.rs
@@ -51,8 +51,8 @@
 
 use pmoupnp::define_service;
 
-pub mod variables;
 pub mod actions;
+pub mod variables;
 
 use actions::{GETMUTE, GETVOLUME, SETMUTE, SETVOLUME};
 use variables::{A_ARG_TYPE_CHANNEL, A_ARG_TYPE_INSTANCE_ID, MUTE, VOLUME};
diff --git a/pmomediarenderer/src/renderingcontrol/variables/mod.rs b/pmomediarenderer/src/renderingcontrol/variables/mod.rs
index 11a2e2c4..9ab5260d 100644
--- a/pmomediarenderer/src/renderingcontrol/variables/mod.rs
+++ b/pmomediarenderer/src/renderingcontrol/variables/mod.rs
@@ -1,9 +1,9 @@
-mod a_arg_type_instanceid;
 mod a_arg_type_channel;
-mod volume;
+mod a_arg_type_instanceid;
 mod mute;
+mod volume;
 
-pub use a_arg_type_instanceid::A_ARG_TYPE_INSTANCE_ID;
 pub use a_arg_type_channel::A_ARG_TYPE_CHANNEL;
-pub use volume::VOLUME;
+pub use a_arg_type_instanceid::A_ARG_TYPE_INSTANCE_ID;
 pub use mute::MUTE;
+pub use volume::VOLUME;
diff --git a/pmomediaserver/src/connectionmanager/actions/getcurrentconnectioninfo.rs b/pmomediaserver/src/connectionmanager/actions/getcurrentconnectioninfo.rs
index cebc78da..b7a928eb 100644
--- a/pmomediaserver/src/connectionmanager/actions/getcurrentconnectioninfo.rs
+++ b/pmomediaserver/src/connectionmanager/actions/getcurrentconnectioninfo.rs
@@ -1,6 +1,6 @@
 use crate::connectionmanager::variables::{
-    A_ARG_TYPE_CONNECTIONID, A_ARG_TYPE_RCSID, A_ARG_TYPE_AVTRANSPORTID,
-    A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_DIRECTION, A_ARG_TYPE_CONNECTIONSTATUS,
+    A_ARG_TYPE_AVTRANSPORTID, A_ARG_TYPE_CONNECTIONID, A_ARG_TYPE_CONNECTIONSTATUS,
+    A_ARG_TYPE_DIRECTION, A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_RCSID,
 };
 use pmoupnp::define_action;
 
diff --git a/pmomediaserver/src/connectionmanager/actions/getprotocolinfo.rs b/pmomediaserver/src/connectionmanager/actions/getprotocolinfo.rs
index b2097b0c..eeb51499 100644
--- a/pmomediaserver/src/connectionmanager/actions/getprotocolinfo.rs
+++ b/pmomediaserver/src/connectionmanager/actions/getprotocolinfo.rs
@@ -1,4 +1,4 @@
-use crate::connectionmanager::variables::{SOURCEPROTOCOLINFO, SINKPROTOCOLINFO};
+use crate::connectionmanager::variables::{SINKPROTOCOLINFO, SOURCEPROTOCOLINFO};
 use pmoupnp::define_action;
 
 define_action! {
diff --git a/pmomediaserver/src/connectionmanager/actions/mod.rs b/pmomediaserver/src/connectionmanager/actions/mod.rs
index b9ccd37b..758e55ce 100644
--- a/pmomediaserver/src/connectionmanager/actions/mod.rs
+++ b/pmomediaserver/src/connectionmanager/actions/mod.rs
@@ -1,7 +1,7 @@
-mod getprotocolinfo;
 mod getcurrentconnectionids;
 mod getcurrentconnectioninfo;
+mod getprotocolinfo;
 
-pub use getprotocolinfo::GETPROTOCOLINFO;
 pub use getcurrentconnectionids::GETCURRENTCONNECTIONIDS;
 pub use getcurrentconnectioninfo::GETCURRENTCONNECTIONINFO;
+pub use getprotocolinfo::GETPROTOCOLINFO;
diff --git a/pmomediaserver/src/connectionmanager/mod.rs b/pmomediaserver/src/connectionmanager/mod.rs
index b0fee00d..5af43b4f 100644
--- a/pmomediaserver/src/connectionmanager/mod.rs
+++ b/pmomediaserver/src/connectionmanager/mod.rs
@@ -65,14 +65,14 @@
 
 use pmoupnp::define_service;
 
-pub mod variables;
 pub mod actions;
+pub mod variables;
 
 use actions::{GETCURRENTCONNECTIONIDS, GETCURRENTCONNECTIONINFO, GETPROTOCOLINFO};
 use variables::{
     A_ARG_TYPE_AVTRANSPORTID, A_ARG_TYPE_CONNECTIONID, A_ARG_TYPE_CONNECTIONSTATUS,
-    A_ARG_TYPE_DIRECTION, A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_RCSID,
-    CURRENTCONNECTIONIDS, SINKPROTOCOLINFO, SOURCEPROTOCOLINFO
+    A_ARG_TYPE_DIRECTION, A_ARG_TYPE_PROTOCOLINFO, A_ARG_TYPE_RCSID, CURRENTCONNECTIONIDS,
+    SINKPROTOCOLINFO, SOURCEPROTOCOLINFO,
 };
 
 // Service ConnectionManager:1 conforme à la spécification UPnP AV pour MediaServer
diff --git a/pmomediaserver/src/connectionmanager/variables/mod.rs b/pmomediaserver/src/connectionmanager/variables/mod.rs
index f2c1ff30..e833da0a 100644
--- a/pmomediaserver/src/connectionmanager/variables/mod.rs
+++ b/pmomediaserver/src/connectionmanager/variables/mod.rs
@@ -1,19 +1,19 @@
+mod a_arg_type_avtransportid;
 mod a_arg_type_connectionid;
 mod a_arg_type_connectionstatus;
 mod a_arg_type_direction;
 mod a_arg_type_protocolinfo;
 mod a_arg_type_rcsid;
-mod a_arg_type_avtransportid;
 mod currentconnectionids;
-mod sourceprotocolinfo;
 mod sinkprotocolinfo;
+mod sourceprotocolinfo;
 
+pub use a_arg_type_avtransportid::A_ARG_TYPE_AVTRANSPORTID;
 pub use a_arg_type_connectionid::A_ARG_TYPE_CONNECTIONID;
 pub use a_arg_type_connectionstatus::A_ARG_TYPE_CONNECTIONSTATUS;
 pub use a_arg_type_direction::A_ARG_TYPE_DIRECTION;
 pub use a_arg_type_protocolinfo::A_ARG_TYPE_PROTOCOLINFO;
 pub use a_arg_type_rcsid::A_ARG_TYPE_RCSID;
-pub use a_arg_type_avtransportid::A_ARG_TYPE_AVTRANSPORTID;
 pub use currentconnectionids::CURRENTCONNECTIONIDS;
-pub use sourceprotocolinfo::SOURCEPROTOCOLINFO;
 pub use sinkprotocolinfo::SINKPROTOCOLINFO;
+pub use sourceprotocolinfo::SOURCEPROTOCOLINFO;
diff --git a/pmomediaserver/src/content_handler.rs b/pmomediaserver/src/content_handler.rs
index 4a4e02d3..d7a9c434 100644
--- a/pmomediaserver/src/content_handler.rs
+++ b/pmomediaserver/src/content_handler.rs
@@ -10,8 +10,8 @@
 //! - **Search** : Recherche dans les sources qui le supportent
 //! - **Update ID** : Suivi des changements pour les notifications UPnP
 
-use pmosource::api::{list_all_sources, get_source as get_source_from_registry};
 use pmodidl::{Container, DIDLLite};
+use pmosource::api::{get_source as get_source_from_registry, list_all_sources};
 use pmosource::{BrowseResult, MusicSource};
 use std::sync::Arc;
 
@@ -28,8 +28,7 @@ fn to_didl_lite(containers: &[Container], items: &[pmodidl::Item]) -> Result<Str
         items: items.to_vec(),
     };
 
-    quick_xml::se::to_string(&didl)
-        .map_err(|e| format!("Failed to serialize DIDL-Lite: {}", e))
+    quick_xml::se::to_string(&didl).map_err(|e| format!("Failed to serialize DIDL-Lite: {}", e))
 }
 
 /// Handler pour le service ContentDirectory
@@ -208,11 +207,7 @@ impl ContentHandler {
             requested_count as usize
         };
 
-        let paginated: Vec<Container> = containers
-            .into_iter()
-            .skip(start)
-            .take(count)
-            .collect();
+        let paginated: Vec<Container> = containers.into_iter().skip(start).take(count).collect();
 
         let returned = paginated.len();
         let didl = to_didl_lite(&paginated, &[])?;
@@ -278,11 +273,7 @@ impl ContentHandler {
             // On commence dans les items
             containers.clear();
             let item_start = start - total_containers;
-            items = items
-                .into_iter()
-                .skip(item_start)
-                .take(count)
-                .collect();
+            items = items.into_iter().skip(item_start).take(count).collect();
         }
 
         let returned = (containers.len() + items.len()) as u32;
diff --git a/pmomediaserver/src/contentdirectory/actions/browse.rs b/pmomediaserver/src/contentdirectory/actions/browse.rs
index e8ad1629..dcbd9f9b 100644
--- a/pmomediaserver/src/contentdirectory/actions/browse.rs
+++ b/pmomediaserver/src/contentdirectory/actions/browse.rs
@@ -1,10 +1,9 @@
+use crate::contentdirectory::handlers;
 use crate::contentdirectory::variables::{
-    A_ARG_TYPE_OBJECTID, A_ARG_TYPE_BROWSEFLAG, A_ARG_TYPE_FILTER,
-    A_ARG_TYPE_SORTCRITERIA, A_ARG_TYPE_INDEX, A_ARG_TYPE_COUNT,
-    A_ARG_TYPE_RESULT, A_ARG_TYPE_UPDATEID,
+    A_ARG_TYPE_BROWSEFLAG, A_ARG_TYPE_COUNT, A_ARG_TYPE_FILTER, A_ARG_TYPE_INDEX,
+    A_ARG_TYPE_OBJECTID, A_ARG_TYPE_RESULT, A_ARG_TYPE_SORTCRITERIA, A_ARG_TYPE_UPDATEID,
 };
 use pmoupnp::define_action;
-use crate::contentdirectory::handlers;
 
 define_action! {
     pub static BROWSE = "Browse" stateless {
diff --git a/pmomediaserver/src/contentdirectory/actions/getsearchcapabilities.rs b/pmomediaserver/src/contentdirectory/actions/getsearchcapabilities.rs
index fe73ba92..914bd650 100644
--- a/pmomediaserver/src/contentdirectory/actions/getsearchcapabilities.rs
+++ b/pmomediaserver/src/contentdirectory/actions/getsearchcapabilities.rs
@@ -1,6 +1,6 @@
+use crate::contentdirectory::handlers;
 use crate::contentdirectory::variables::SEARCHCAPABILITIES;
 use pmoupnp::define_action;
-use crate::contentdirectory::handlers;
 
 define_action! {
     pub static GETSEARCHCAPABILITIES = "GetSearchCapabilities" stateless {
diff --git a/pmomediaserver/src/contentdirectory/actions/getsortcapabilities.rs b/pmomediaserver/src/contentdirectory/actions/getsortcapabilities.rs
index 944e7e24..071bf148 100644
--- a/pmomediaserver/src/contentdirectory/actions/getsortcapabilities.rs
+++ b/pmomediaserver/src/contentdirectory/actions/getsortcapabilities.rs
@@ -1,6 +1,6 @@
+use crate::contentdirectory::handlers;
 use crate::contentdirectory::variables::SORTCAPABILITIES;
 use pmoupnp::define_action;
-use crate::contentdirectory::handlers;
 
 define_action! {
     pub static GETSORTCAPABILITIES = "GetSortCapabilities" stateless {
diff --git a/pmomediaserver/src/contentdirectory/actions/getsystemupdateid.rs b/pmomediaserver/src/contentdirectory/actions/getsystemupdateid.rs
index a80f200e..b0daa1bf 100644
--- a/pmomediaserver/src/contentdirectory/actions/getsystemupdateid.rs
+++ b/pmomediaserver/src/contentdirectory/actions/getsystemupdateid.rs
@@ -1,6 +1,6 @@
+use crate::contentdirectory::handlers;
 use crate::contentdirectory::variables::SYSTEMUPDATEID;
 use pmoupnp::define_action;
-use crate::contentdirectory::handlers;
 
 define_action! {
     pub static GETSYSTEMUPDATEID = "GetSystemUpdateID" stateless {
diff --git a/pmomediaserver/src/contentdirectory/actions/mod.rs b/pmomediaserver/src/contentdirectory/actions/mod.rs
index 32d95832..f83a9903 100644
--- a/pmomediaserver/src/contentdirectory/actions/mod.rs
+++ b/pmomediaserver/src/contentdirectory/actions/mod.rs
@@ -1,11 +1,11 @@
 mod browse;
-mod search;
 mod getsearchcapabilities;
 mod getsortcapabilities;
 mod getsystemupdateid;
+mod search;
 
 pub use browse::BROWSE;
-pub use search::SEARCH;
 pub use getsearchcapabilities::GETSEARCHCAPABILITIES;
 pub use getsortcapabilities::GETSORTCAPABILITIES;
 pub use getsystemupdateid::GETSYSTEMUPDATEID;
+pub use search::SEARCH;
diff --git a/pmomediaserver/src/contentdirectory/actions/search.rs b/pmomediaserver/src/contentdirectory/actions/search.rs
index cc7d81fa..f8e5fb9e 100644
--- a/pmomediaserver/src/contentdirectory/actions/search.rs
+++ b/pmomediaserver/src/contentdirectory/actions/search.rs
@@ -1,10 +1,9 @@
+use crate::contentdirectory::handlers;
 use crate::contentdirectory::variables::{
-    A_ARG_TYPE_OBJECTID, A_ARG_TYPE_SEARCHCRITERIA, A_ARG_TYPE_FILTER,
-    A_ARG_TYPE_SORTCRITERIA, A_ARG_TYPE_INDEX, A_ARG_TYPE_COUNT,
-    A_ARG_TYPE_RESULT, A_ARG_TYPE_UPDATEID,
+    A_ARG_TYPE_COUNT, A_ARG_TYPE_FILTER, A_ARG_TYPE_INDEX, A_ARG_TYPE_OBJECTID, A_ARG_TYPE_RESULT,
+    A_ARG_TYPE_SEARCHCRITERIA, A_ARG_TYPE_SORTCRITERIA, A_ARG_TYPE_UPDATEID,
 };
 use pmoupnp::define_action;
-use crate::contentdirectory::handlers;
 
 define_action! {
     pub static SEARCH = "Search" stateless {
diff --git a/pmomediaserver/src/contentdirectory/handlers.rs b/pmomediaserver/src/contentdirectory/handlers.rs
index 71a63557..413f09f6 100644
--- a/pmomediaserver/src/contentdirectory/handlers.rs
+++ b/pmomediaserver/src/contentdirectory/handlers.rs
@@ -23,9 +23,9 @@
 //! - [`get_sort_capabilities_handler`] : Capacités de tri supportées
 //! - [`get_system_update_id_handler`] : ID de mise à jour du système
 
-use pmoupnp::{action_handler, get, set};
-use pmoupnp::actions::{ActionError, ActionHandler};
 use crate::content_handler::ContentHandler;
+use pmoupnp::actions::{ActionError, ActionHandler};
+use pmoupnp::{action_handler, get, set};
 use tracing::{debug, error};
 
 /// Handler pour l'action Browse.
@@ -76,7 +76,10 @@ pub fn browse_handler() -> ActionHandler {
         set!(&mut data, "TotalMatches", total);
         set!(&mut data, "UpdateID", update_id);
 
-        debug!("✅ Browse completed: returned={}, total={}", returned, total);
+        debug!(
+            "✅ Browse completed: returned={}, total={}",
+            returned, total
+        );
         Ok(data)
     })
 }
@@ -128,7 +131,10 @@ pub fn search_handler() -> ActionHandler {
         set!(&mut data, "TotalMatches", total);
         set!(&mut data, "UpdateID", update_id);
 
-        debug!("✅ Search completed: returned={}, total={}", returned, total);
+        debug!(
+            "✅ Search completed: returned={}, total={}",
+            returned, total
+        );
         Ok(data)
     })
 }
diff --git a/pmomediaserver/src/contentdirectory/mod.rs b/pmomediaserver/src/contentdirectory/mod.rs
index e95d770f..4f1054c3 100644
--- a/pmomediaserver/src/contentdirectory/mod.rs
+++ b/pmomediaserver/src/contentdirectory/mod.rs
@@ -74,18 +74,15 @@
 
 use pmoupnp::define_service;
 
-pub mod variables;
 pub mod actions;
 pub mod handlers;
+pub mod variables;
 
-use actions::{
-    BROWSE, SEARCH, GETSEARCHCAPABILITIES, GETSORTCAPABILITIES, GETSYSTEMUPDATEID
-};
+use actions::{BROWSE, GETSEARCHCAPABILITIES, GETSORTCAPABILITIES, GETSYSTEMUPDATEID, SEARCH};
 use variables::{
-    A_ARG_TYPE_OBJECTID, A_ARG_TYPE_BROWSEFLAG, A_ARG_TYPE_FILTER,
-    A_ARG_TYPE_SORTCRITERIA, A_ARG_TYPE_INDEX, A_ARG_TYPE_COUNT,
-    A_ARG_TYPE_UPDATEID, A_ARG_TYPE_RESULT, A_ARG_TYPE_SEARCHCRITERIA,
-    SEARCHCAPABILITIES, SORTCAPABILITIES, SYSTEMUPDATEID
+    A_ARG_TYPE_BROWSEFLAG, A_ARG_TYPE_COUNT, A_ARG_TYPE_FILTER, A_ARG_TYPE_INDEX,
+    A_ARG_TYPE_OBJECTID, A_ARG_TYPE_RESULT, A_ARG_TYPE_SEARCHCRITERIA, A_ARG_TYPE_SORTCRITERIA,
+    A_ARG_TYPE_UPDATEID, SEARCHCAPABILITIES, SORTCAPABILITIES, SYSTEMUPDATEID,
 };
 
 // Service ContentDirectory:1 conforme à la spécification UPnP AV pour MediaServer
diff --git a/pmomediaserver/src/contentdirectory/variables/mod.rs b/pmomediaserver/src/contentdirectory/variables/mod.rs
index e1a6df5b..6660c23c 100644
--- a/pmomediaserver/src/contentdirectory/variables/mod.rs
+++ b/pmomediaserver/src/contentdirectory/variables/mod.rs
@@ -1,25 +1,25 @@
-mod a_arg_type_objectid;
 mod a_arg_type_browseflag;
-mod a_arg_type_filter;
-mod a_arg_type_sortcriteria;
-mod a_arg_type_index;
 mod a_arg_type_count;
-mod a_arg_type_updateid;
+mod a_arg_type_filter;
+mod a_arg_type_index;
+mod a_arg_type_objectid;
 mod a_arg_type_result;
 mod a_arg_type_searchcriteria;
+mod a_arg_type_sortcriteria;
+mod a_arg_type_updateid;
 mod searchcapabilities;
 mod sortcapabilities;
 mod systemupdateid;
 
-pub use a_arg_type_objectid::A_ARG_TYPE_OBJECTID;
 pub use a_arg_type_browseflag::A_ARG_TYPE_BROWSEFLAG;
-pub use a_arg_type_filter::A_ARG_TYPE_FILTER;
-pub use a_arg_type_sortcriteria::A_ARG_TYPE_SORTCRITERIA;
-pub use a_arg_type_index::A_ARG_TYPE_INDEX;
 pub use a_arg_type_count::A_ARG_TYPE_COUNT;
-pub use a_arg_type_updateid::A_ARG_TYPE_UPDATEID;
+pub use a_arg_type_filter::A_ARG_TYPE_FILTER;
+pub use a_arg_type_index::A_ARG_TYPE_INDEX;
+pub use a_arg_type_objectid::A_ARG_TYPE_OBJECTID;
 pub use a_arg_type_result::A_ARG_TYPE_RESULT;
 pub use a_arg_type_searchcriteria::A_ARG_TYPE_SEARCHCRITERIA;
+pub use a_arg_type_sortcriteria::A_ARG_TYPE_SORTCRITERIA;
+pub use a_arg_type_updateid::A_ARG_TYPE_UPDATEID;
 pub use searchcapabilities::SEARCHCAPABILITIES;
 pub use sortcapabilities::SORTCAPABILITIES;
 pub use systemupdateid::SYSTEMUPDATEID;
diff --git a/pmomediaserver/src/device.rs b/pmomediaserver/src/device.rs
index 12c54bc6..9ea04a24 100644
--- a/pmomediaserver/src/device.rs
+++ b/pmomediaserver/src/device.rs
@@ -3,11 +3,8 @@
 use once_cell::sync::Lazy;
 use std::sync::Arc;
 
+use crate::{connectionmanager::CONNECTIONMANAGER, contentdirectory::CONTENTDIRECTORY};
 use pmoupnp::devices::Device;
-use crate::{
-    contentdirectory::CONTENTDIRECTORY,
-    connectionmanager::CONNECTIONMANAGER,
-};
 
 /// Device MediaServer UPnP.
 ///
@@ -52,10 +49,12 @@ pub static MEDIA_SERVER: Lazy<Arc<Device>> = Lazy::new(|| {
     device.set_udn_prefix("pmomusic".to_string());
 
     // Ajouter les deux services obligatoires
-    device.add_service(Arc::clone(&CONTENTDIRECTORY))
+    device
+        .add_service(Arc::clone(&CONTENTDIRECTORY))
         .expect("Failed to add ContentDirectory service");
 
-    device.add_service(Arc::clone(&CONNECTIONMANAGER))
+    device
+        .add_service(Arc::clone(&CONNECTIONMANAGER))
         .expect("Failed to add ConnectionManager service");
 
     Arc::new(device)
diff --git a/pmomediaserver/src/lib.rs b/pmomediaserver/src/lib.rs
index 2f0566fc..796e8ee2 100644
--- a/pmomediaserver/src/lib.rs
+++ b/pmomediaserver/src/lib.rs
@@ -63,23 +63,23 @@
 //! server.register_qobuz_from_config().await?;
 //! ```
 
-pub mod contentdirectory;
 pub mod connectionmanager;
-pub mod device;
-pub mod source_registry;
-pub mod server_ext;
 pub mod content_handler;
+pub mod contentdirectory;
+pub mod device;
+pub mod server_ext;
+pub mod source_registry;
 pub mod sources;
 
 // API REST pour l'enregistrement des sources (requires features qobuz/paradise)
 #[cfg(any(feature = "qobuz", feature = "paradise"))]
 pub mod sources_api;
 
-pub use device::MEDIA_SERVER;
-pub use source_registry::SourceRegistry;
-pub use server_ext::{MediaServerExt, get_source_registry, MusicSourceExt};
 pub use content_handler::ContentHandler;
-pub use sources::{SourcesExt, SourceInitError};
+pub use device::MEDIA_SERVER;
+pub use server_ext::{MediaServerExt, MusicSourceExt, get_source_registry};
+pub use source_registry::SourceRegistry;
+pub use sources::{SourceInitError, SourcesExt};
 
 // Re-export sources when features are enabled
 #[cfg(feature = "qobuz")]
diff --git a/pmomediaserver/src/server_ext.rs b/pmomediaserver/src/server_ext.rs
index aeb5561d..025aa227 100644
--- a/pmomediaserver/src/server_ext.rs
+++ b/pmomediaserver/src/server_ext.rs
@@ -7,8 +7,8 @@
 //! méthodes spécifiques au MediaServer UPnP.
 
 use async_trait::async_trait;
-use pmosource::MusicSource;
 use pmoserver::Server;
+use pmosource::MusicSource;
 use std::sync::Arc;
 
 // Réexporter le trait de base de pmosource
@@ -23,7 +23,10 @@ pub use pmosource::MusicSourceExt;
 ///
 /// let sources = pmosource::api::list_all_sources().await;
 /// ```
-#[deprecated(since = "0.2.0", note = "Use pmosource::api::list_all_sources() directly")]
+#[deprecated(
+    since = "0.2.0",
+    note = "Use pmosource::api::list_all_sources() directly"
+)]
 pub async fn get_source_registry() -> Vec<Arc<dyn MusicSource>> {
     pmosource::api::list_all_sources().await
 }
diff --git a/pmomediaserver/src/source_registry.rs b/pmomediaserver/src/source_registry.rs
index ac99d145..bf272701 100644
--- a/pmomediaserver/src/source_registry.rs
+++ b/pmomediaserver/src/source_registry.rs
@@ -210,8 +210,8 @@ impl Default for SourceRegistry {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use pmosource::{MusicSource, Result, BrowseResult};
     use pmodidl::{Container, Item};
+    use pmosource::{BrowseResult, MusicSource, Result};
     use std::time::SystemTime;
 
     #[derive(Debug)]
@@ -308,9 +308,15 @@ mod tests {
     async fn test_list_all() {
         let registry = SourceRegistry::new();
 
-        registry.register(Arc::new(TestSource::new("test-1", "Test 1"))).await;
-        registry.register(Arc::new(TestSource::new("test-2", "Test 2"))).await;
-        registry.register(Arc::new(TestSource::new("test-3", "Test 3"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-1", "Test 1")))
+            .await;
+        registry
+            .register(Arc::new(TestSource::new("test-2", "Test 2")))
+            .await;
+        registry
+            .register(Arc::new(TestSource::new("test-3", "Test 3")))
+            .await;
 
         let sources = registry.list_all().await;
         assert_eq!(sources.len(), 3);
@@ -321,17 +327,23 @@ mod tests {
         let registry = SourceRegistry::new();
         assert_eq!(registry.count().await, 0);
 
-        registry.register(Arc::new(TestSource::new("test-1", "Test 1"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-1", "Test 1")))
+            .await;
         assert_eq!(registry.count().await, 1);
 
-        registry.register(Arc::new(TestSource::new("test-2", "Test 2"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-2", "Test 2")))
+            .await;
         assert_eq!(registry.count().await, 2);
     }
 
     #[tokio::test]
     async fn test_remove() {
         let registry = SourceRegistry::new();
-        registry.register(Arc::new(TestSource::new("test-1", "Test 1"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-1", "Test 1")))
+            .await;
 
         assert!(registry.contains("test-1").await);
         assert!(registry.remove("test-1").await);
@@ -345,7 +357,9 @@ mod tests {
 
         assert!(!registry.contains("test-1").await);
 
-        registry.register(Arc::new(TestSource::new("test-1", "Test 1"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-1", "Test 1")))
+            .await;
 
         assert!(registry.contains("test-1").await);
         assert!(!registry.contains("test-2").await);
@@ -355,11 +369,15 @@ mod tests {
     async fn test_replace_source() {
         let registry = SourceRegistry::new();
 
-        registry.register(Arc::new(TestSource::new("test-1", "Old Name"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-1", "Old Name")))
+            .await;
         let old = registry.get("test-1").await.unwrap();
         assert_eq!(old.name(), "Old Name");
 
-        registry.register(Arc::new(TestSource::new("test-1", "New Name"))).await;
+        registry
+            .register(Arc::new(TestSource::new("test-1", "New Name")))
+            .await;
         let new = registry.get("test-1").await.unwrap();
         assert_eq!(new.name(), "New Name");
 
diff --git a/pmomediaserver/src/sources.rs b/pmomediaserver/src/sources.rs
index 20bdf183..aa8895b0 100644
--- a/pmomediaserver/src/sources.rs
+++ b/pmomediaserver/src/sources.rs
@@ -3,8 +3,8 @@
 //! Ce module fournit des helpers pour créer et enregistrer facilement des sources
 //! musicales préconfigurées à partir de la configuration système.
 
-use pmosource::MusicSourceExt;
 use pmoserver::Server;
+use pmosource::MusicSourceExt;
 use std::sync::Arc;
 
 /// Erreur lors de l'initialisation d'une source
@@ -93,7 +93,11 @@ pub trait SourcesExt {
     /// server.register_qobuz_with_credentials("user@example.com", "password").await?;
     /// ```
     #[cfg(feature = "qobuz")]
-    async fn register_qobuz_with_credentials(&mut self, username: &str, password: &str) -> Result<()>;
+    async fn register_qobuz_with_credentials(
+        &mut self,
+        username: &str,
+        password: &str,
+    ) -> Result<()>;
 
     /// Enregistre la source Radio Paradise
     ///
@@ -141,7 +145,11 @@ impl SourcesExt for Server {
     }
 
     #[cfg(feature = "qobuz")]
-    async fn register_qobuz_with_credentials(&mut self, username: &str, password: &str) -> Result<()> {
+    async fn register_qobuz_with_credentials(
+        &mut self,
+        username: &str,
+        password: &str,
+    ) -> Result<()> {
         use pmoqobuz::{QobuzClient, QobuzSource};
 
         tracing::info!("Initializing Qobuz source with explicit credentials...");
@@ -165,18 +173,19 @@ impl SourcesExt for Server {
 
     #[cfg(feature = "paradise")]
     async fn register_paradise(&mut self) -> Result<()> {
-        use pmoparadise::{RadioParadiseClient, RadioParadiseSource, RadioParadiseExt};
+        use pmoparadise::{RadioParadiseClient, RadioParadiseExt, RadioParadiseSource};
 
         tracing::info!("Initializing Radio Paradise source...");
 
         // Créer le client (Radio Paradise ne nécessite pas d'authentification)
-        let client = RadioParadiseClient::new()
-            .await
-            .map_err(|e| SourceInitError::ParadiseError(format!("Failed to create client: {}", e)))?;
+        let client = RadioParadiseClient::new().await.map_err(|e| {
+            SourceInitError::ParadiseError(format!("Failed to create client: {}", e))
+        })?;
 
         // Créer la source depuis le registry avec capacité FIFO par défaut
-        let source = RadioParadiseSource::from_registry_default(client)
-            .map_err(|e| SourceInitError::ParadiseError(format!("Failed to create source: {}", e)))?;
+        let source = RadioParadiseSource::from_registry_default(client).map_err(|e| {
+            SourceInitError::ParadiseError(format!("Failed to create source: {}", e))
+        })?;
 
         // Enregistrer la source
         // Note: La FIFO sera peuplée automatiquement lors du premier browse
diff --git a/pmomediaserver/src/sources_api.rs b/pmomediaserver/src/sources_api.rs
index d4231191..b26c5586 100644
--- a/pmomediaserver/src/sources_api.rs
+++ b/pmomediaserver/src/sources_api.rs
@@ -13,13 +13,7 @@
 //! Ces endpoints sont définis ici plutôt que dans `pmosource` pour éviter les
 //! dépendances circulaires (pmoqobuz et pmoparadise dépendent de pmosource).
 
-use axum::{
-    extract::Json,
-    http::StatusCode,
-    response::IntoResponse,
-    routing::post,
-    Router,
-};
+use axum::{Router, extract::Json, http::StatusCode, response::IntoResponse, routing::post};
 use pmosource::MusicSource;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
diff --git a/pmoparadise/examples/extract_track.rs b/pmoparadise/examples/extract_track.rs
index 398cde99..8d403893 100644
--- a/pmoparadise/examples/extract_track.rs
+++ b/pmoparadise/examples/extract_track.rs
@@ -43,11 +43,13 @@ async fn main() -> Result<()> {
     // Display all tracks
     println!("Available Tracks:");
     for (index, song) in block.songs_ordered() {
-        println!("  {}. {} - {} ({:.1}s)",
-                 index,
-                 song.artist,
-                 song.title,
-                 song.duration as f64 / 1000.0);
+        println!(
+            "  {}. {} - {} ({:.1}s)",
+            index,
+            song.artist,
+            song.title,
+            song.duration as f64 / 1000.0
+        );
     }
     println!();
 
@@ -67,7 +69,10 @@ async fn main() -> Result<()> {
         println!("Track Metadata:");
         println!("  Sample Rate: {} Hz", track_stream.metadata.sample_rate);
         println!("  Channels: {}", track_stream.metadata.channels);
-        println!("  Bits Per Sample: {}", track_stream.metadata.bits_per_sample);
+        println!(
+            "  Bits Per Sample: {}",
+            track_stream.metadata.bits_per_sample
+        );
         println!("  Total Samples: {}", track_stream.metadata.total_samples);
         println!();
 
@@ -86,10 +91,15 @@ async fn main() -> Result<()> {
         let (start, duration) = client.track_position_seconds(&block, index)?;
         println!("Track {}: {} - {}", index, song.artist, song.title);
         println!("  mpv command:");
-        println!("    mpv --start={:.3} --length={:.3} '{}'", start, duration, block.url);
+        println!(
+            "    mpv --start={:.3} --length={:.3} '{}'",
+            start, duration, block.url
+        );
         println!("  ffmpeg command (extract to file):");
-        println!("    ffmpeg -ss {:.3} -t {:.3} -i '{}' -c copy track_{}.flac",
-                 start, duration, block.url, index);
+        println!(
+            "    ffmpeg -ss {:.3} -t {:.3} -i '{}' -c copy track_{}.flac",
+            start, duration, block.url, index
+        );
         println!();
     }
 
diff --git a/pmoparadise/examples/now_playing.rs b/pmoparadise/examples/now_playing.rs
index edcd0aaa..c0c2fbdb 100644
--- a/pmoparadise/examples/now_playing.rs
+++ b/pmoparadise/examples/now_playing.rs
@@ -48,9 +48,11 @@ async fn main() -> Result<()> {
         if let Some(rating) = song.rating {
             println!("  Rating: {:.1}/10", rating);
         }
-        println!("  Duration: {}:{:02}",
-                 song.duration / 60000,
-                 (song.duration % 60000) / 1000);
+        println!(
+            "  Duration: {}:{:02}",
+            song.duration / 60000,
+            (song.duration % 60000) / 1000
+        );
 
         // Display cover URL
         if let Some(cover) = &song.cover {
diff --git a/pmoparadise/examples/show_source_image.rs b/pmoparadise/examples/show_source_image.rs
index dffb57e0..66902a16 100644
--- a/pmoparadise/examples/show_source_image.rs
+++ b/pmoparadise/examples/show_source_image.rs
@@ -5,7 +5,7 @@
 //! - Accessing the embedded WebP image
 //! - Optionally saving it to a file
 
-use pmoparadise::{RadioParadiseSource, RadioParadiseClient};
+use pmoparadise::{RadioParadiseClient, RadioParadiseSource};
 use pmosource::MusicSource;
 use std::fs;
 use std::io::Write;
diff --git a/pmoparadise/examples/stream_block.rs b/pmoparadise/examples/stream_block.rs
index d7cb8533..39935f3d 100644
--- a/pmoparadise/examples/stream_block.rs
+++ b/pmoparadise/examples/stream_block.rs
@@ -38,7 +38,10 @@ async fn main() -> Result<()> {
     eprintln!("Current Block:");
     eprintln!("  Event: {}", current_block.event);
     eprintln!("  Songs: {}", current_block.song_count());
-    eprintln!("  Duration: {:.1} minutes", current_block.length as f64 / 60000.0);
+    eprintln!(
+        "  Duration: {:.1} minutes",
+        current_block.length as f64 / 60000.0
+    );
     eprintln!("  URL: {}\n", current_block.url);
 
     // Display tracklist
@@ -51,7 +54,10 @@ async fn main() -> Result<()> {
     // Prefetch next block in advance
     eprintln!("Prefetching next block...");
     client.prefetch_next(&current_block).await?;
-    eprintln!("Next block prefetched: {}\n", client.next_block_url().unwrap());
+    eprintln!(
+        "Next block prefetched: {}\n",
+        client.next_block_url().unwrap()
+    );
 
     // Stream the block
     eprintln!("Streaming block... (writing to stdout)");
@@ -71,12 +77,18 @@ async fn main() -> Result<()> {
 
         // Progress indicator (to stderr so it doesn't interfere with piped audio)
         if total_bytes % (1024 * 1024) == 0 {
-            eprintln!("  Downloaded: {:.1} MB", total_bytes as f64 / 1024.0 / 1024.0);
+            eprintln!(
+                "  Downloaded: {:.1} MB",
+                total_bytes as f64 / 1024.0 / 1024.0
+            );
         }
     }
 
     eprintln!("\nBlock streaming complete!");
-    eprintln!("Total downloaded: {:.2} MB", total_bytes as f64 / 1024.0 / 1024.0);
+    eprintln!(
+        "Total downloaded: {:.2} MB",
+        total_bytes as f64 / 1024.0 / 1024.0
+    );
 
     // In a real application, you would now:
     // 1. Get the next block using prefetched metadata
diff --git a/pmoparadise/examples/upnp_mediaserver.rs b/pmoparadise/examples/upnp_mediaserver.rs
index 3a3e3966..b8fb9ed1 100644
--- a/pmoparadise/examples/upnp_mediaserver.rs
+++ b/pmoparadise/examples/upnp_mediaserver.rs
@@ -48,7 +48,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Look for 'Radio Paradise FLAC' in your DLNA/UPnP clients.");
     println!();
     println!("ContentDirectory service available at:");
-    println!("  http://localhost:8080/upnp/device/{}/service/ContentDirectory", server.udn());
+    println!(
+        "  http://localhost:8080/upnp/device/{}/service/ContentDirectory",
+        server.udn()
+    );
     println!();
     println!("Press Ctrl+C to stop the server.");
     println!();
diff --git a/pmoparadise/examples/with_cache.rs b/pmoparadise/examples/with_cache.rs
index 04bfb3ce..563ed755 100644
--- a/pmoparadise/examples/with_cache.rs
+++ b/pmoparadise/examples/with_cache.rs
@@ -8,9 +8,9 @@
 //! cargo run --example with_cache --features cache
 //! ```
 
-use pmoparadise::{RadioParadiseClient, RadioParadiseSource};
-use pmocovers::Cache as CoverCache;
 use pmoaudiocache::AudioCache;
+use pmocovers::Cache as CoverCache;
+use pmoparadise::{RadioParadiseClient, RadioParadiseSource};
 use pmosource::MusicSource;
 use std::sync::Arc;
 use tokio::time::{sleep, Duration};
@@ -64,7 +64,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Add current song to the source
     println!("➕ Adding current track to FIFO with caching...");
     if let Some(song) = &now_playing.current_song {
-        source.add_song(block.clone(), song, now_playing.current_song_index.unwrap_or(0)).await?;
+        source
+            .add_song(
+                block.clone(),
+                song,
+                now_playing.current_song_index.unwrap_or(0),
+            )
+            .await?;
         println!("✅ Track added and caching started!");
         println!("   - Cover image will be cached to: ./cache/covers/");
         println!("   - Audio will be cached to: ./cache/audio/\n");
@@ -78,7 +84,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("\n📋 Items in FIFO:");
     let items = source.get_items(0, 10).await?;
     for (i, item) in items.iter().enumerate() {
-        println!("   {}. {} - {}",
+        println!(
+            "   {}. {} - {}",
             i + 1,
             item.artist.as_deref().unwrap_or("Unknown"),
             item.title
diff --git a/pmoparadise/src/client.rs b/pmoparadise/src/client.rs
index ea9f3a4c..cdfb6aa8 100644
--- a/pmoparadise/src/client.rs
+++ b/pmoparadise/src/client.rs
@@ -133,11 +133,7 @@ impl RadioParadiseClient {
         #[cfg(feature = "logging")]
         tracing::debug!("Fetching block: {}", url);
 
-        let response = self.client
-            .get(url)
-            .timeout(self.timeout)
-            .send()
-            .await?;
+        let response = self.client.get(url).timeout(self.timeout).send().await?;
 
         if !response.status().is_success() {
             return Err(Error::other(format!(
@@ -381,6 +377,9 @@ mod tests {
     fn test_cover_url() {
         let client = RadioParadiseClient::with_client(Client::new());
         let url = client.cover_url("test.jpg").unwrap();
-        assert_eq!(url.as_str(), "https://img.radioparadise.com/covers/l/test.jpg");
+        assert_eq!(
+            url.as_str(),
+            "https://img.radioparadise.com/covers/l/test.jpg"
+        );
     }
 }
diff --git a/pmoparadise/src/lib.rs b/pmoparadise/src/lib.rs
index 9ee5ab47..886fb4d6 100644
--- a/pmoparadise/src/lib.rs
+++ b/pmoparadise/src/lib.rs
@@ -269,10 +269,12 @@ pub use stream::BlockStream;
 pub use track::{TrackMetadata, TrackStream};
 
 #[cfg(feature = "mediaserver")]
-pub use mediaserver::{RadioParadiseMediaServer, MediaServerBuilder};
+pub use mediaserver::{MediaServerBuilder, RadioParadiseMediaServer};
 
 #[cfg(feature = "pmoserver")]
-pub use pmoserver_ext::{RadioParadiseExt, RadioParadiseState, RadioParadiseApiDoc, create_api_router};
+pub use pmoserver_ext::{
+    create_api_router, RadioParadiseApiDoc, RadioParadiseExt, RadioParadiseState,
+};
 
 // Version information
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/pmoparadise/src/mediaserver/connection_manager.rs b/pmoparadise/src/mediaserver/connection_manager.rs
index afbe1679..4608f6c4 100644
--- a/pmoparadise/src/mediaserver/connection_manager.rs
+++ b/pmoparadise/src/mediaserver/connection_manager.rs
@@ -1,7 +1,7 @@
 //! ConnectionManager service implementation
 
-use pmoupnp::services::Service;
 use pmoupnp::actions::Action;
+use pmoupnp::services::Service;
 use pmoupnp::state_variables::StateVariable;
 use std::sync::Arc;
 
@@ -15,23 +15,20 @@ pub fn create_connection_manager_service() -> Service {
     service.set_service_id("urn:upnp-org:serviceId:ConnectionManager".to_string());
 
     // State variables
-    let source_protocol_info = StateVariable::new(
-        "SourceProtocolInfo".to_string(),
-        "string".to_string(),
-    ).with_send_events(true)
-     .with_default_value(get_protocol_info());
+    let source_protocol_info =
+        StateVariable::new("SourceProtocolInfo".to_string(), "string".to_string())
+            .with_send_events(true)
+            .with_default_value(get_protocol_info());
 
-    let sink_protocol_info = StateVariable::new(
-        "SinkProtocolInfo".to_string(),
-        "string".to_string(),
-    ).with_send_events(true)
-     .with_default_value("".to_string());
+    let sink_protocol_info =
+        StateVariable::new("SinkProtocolInfo".to_string(), "string".to_string())
+            .with_send_events(true)
+            .with_default_value("".to_string());
 
-    let current_connection_ids = StateVariable::new(
-        "CurrentConnectionIDs".to_string(),
-        "string".to_string(),
-    ).with_send_events(true)
-     .with_default_value("0".to_string());
+    let current_connection_ids =
+        StateVariable::new("CurrentConnectionIDs".to_string(), "string".to_string())
+            .with_send_events(true)
+            .with_default_value("0".to_string());
 
     service.add_state_variable(Arc::new(source_protocol_info));
     service.add_state_variable(Arc::new(sink_protocol_info));
@@ -39,14 +36,8 @@ pub fn create_connection_manager_service() -> Service {
 
     // GetProtocolInfo action
     let mut get_protocol_info = Action::new("GetProtocolInfo".to_string());
-    get_protocol_info.add_output_argument(
-        "Source".to_string(),
-        "SourceProtocolInfo".to_string(),
-    );
-    get_protocol_info.add_output_argument(
-        "Sink".to_string(),
-        "SinkProtocolInfo".to_string(),
-    );
+    get_protocol_info.add_output_argument("Source".to_string(), "SourceProtocolInfo".to_string());
+    get_protocol_info.add_output_argument("Sink".to_string(), "SinkProtocolInfo".to_string());
     service.add_action(Arc::new(get_protocol_info));
 
     // GetCurrentConnectionIDs action
@@ -63,10 +54,7 @@ pub fn create_connection_manager_service() -> Service {
         "ConnectionID".to_string(),
         "A_ARG_TYPE_ConnectionID".to_string(),
     );
-    get_connection_info.add_output_argument(
-        "RcsID".to_string(),
-        "A_ARG_TYPE_RcsID".to_string(),
-    );
+    get_connection_info.add_output_argument("RcsID".to_string(), "A_ARG_TYPE_RcsID".to_string());
     get_connection_info.add_output_argument(
         "AVTransportID".to_string(),
         "A_ARG_TYPE_AVTransportID".to_string(),
@@ -83,10 +71,8 @@ pub fn create_connection_manager_service() -> Service {
         "PeerConnectionID".to_string(),
         "A_ARG_TYPE_ConnectionID".to_string(),
     );
-    get_connection_info.add_output_argument(
-        "Direction".to_string(),
-        "A_ARG_TYPE_Direction".to_string(),
-    );
+    get_connection_info
+        .add_output_argument("Direction".to_string(), "A_ARG_TYPE_Direction".to_string());
     get_connection_info.add_output_argument(
         "Status".to_string(),
         "A_ARG_TYPE_ConnectionStatus".to_string(),
@@ -94,34 +80,42 @@ pub fn create_connection_manager_service() -> Service {
     service.add_action(Arc::new(get_connection_info));
 
     // Additional state variables for arguments
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_ConnectionID".to_string(), "i4".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_RcsID".to_string(), "i4".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_AVTransportID".to_string(), "i4".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_ProtocolInfo".to_string(), "string".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_ConnectionManager".to_string(), "string".to_string())
-    ));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_ConnectionID".to_string(),
+        "i4".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_RcsID".to_string(),
+        "i4".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_AVTransportID".to_string(),
+        "i4".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_ProtocolInfo".to_string(),
+        "string".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_ConnectionManager".to_string(),
+        "string".to_string(),
+    )));
     service.add_state_variable(Arc::new(
         StateVariable::new("A_ARG_TYPE_Direction".to_string(), "string".to_string())
-            .with_allowed_values(vec!["Input".to_string(), "Output".to_string()])
+            .with_allowed_values(vec!["Input".to_string(), "Output".to_string()]),
     ));
     service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_ConnectionStatus".to_string(), "string".to_string())
-            .with_allowed_values(vec![
-                "OK".to_string(),
-                "ContentFormatMismatch".to_string(),
-                "InsufficientBandwidth".to_string(),
-                "UnreliableChannel".to_string(),
-                "Unknown".to_string(),
-            ])
+        StateVariable::new(
+            "A_ARG_TYPE_ConnectionStatus".to_string(),
+            "string".to_string(),
+        )
+        .with_allowed_values(vec![
+            "OK".to_string(),
+            "ContentFormatMismatch".to_string(),
+            "InsufficientBandwidth".to_string(),
+            "UnreliableChannel".to_string(),
+            "Unknown".to_string(),
+        ]),
     ));
 
     service
@@ -143,7 +137,8 @@ fn get_protocol_info() -> String {
         "http-get:*:audio/mpeg:*",
         "http-get:*:audio/mp3:*",
         "http-get:*:audio/x-mp3:*",
-    ].join(",")
+    ]
+    .join(",")
 }
 
 #[cfg(test)]
@@ -153,8 +148,14 @@ mod tests {
     #[test]
     fn test_create_connection_manager() {
         let service = create_connection_manager_service();
-        assert_eq!(service.service_type(), "urn:schemas-upnp-org:service:ConnectionManager:1");
-        assert_eq!(service.service_id(), "urn:upnp-org:serviceId:ConnectionManager");
+        assert_eq!(
+            service.service_type(),
+            "urn:schemas-upnp-org:service:ConnectionManager:1"
+        );
+        assert_eq!(
+            service.service_id(),
+            "urn:upnp-org:serviceId:ConnectionManager"
+        );
     }
 
     #[test]
diff --git a/pmoparadise/src/mediaserver/content_directory.rs b/pmoparadise/src/mediaserver/content_directory.rs
index be2e0b03..e7433c18 100644
--- a/pmoparadise/src/mediaserver/content_directory.rs
+++ b/pmoparadise/src/mediaserver/content_directory.rs
@@ -1,35 +1,30 @@
 //! ContentDirectory service implementation
 
 use crate::RadioParadiseClient;
-use pmoupnp::services::Service;
+use pmodidl::{DIDLContainer, DIDLItem, DIDLObject, Resource};
 use pmoupnp::actions::Action;
+use pmoupnp::services::Service;
 use pmoupnp::state_variables::StateVariable;
-use pmodidl::{DIDLObject, DIDLContainer, DIDLItem, Resource};
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
 /// Create a ContentDirectory service for Radio Paradise
 ///
 /// The ContentDirectory service allows browsing Radio Paradise blocks and songs.
-pub fn create_content_directory_service(
-    client: Arc<RwLock<RadioParadiseClient>>,
-) -> Service {
+pub fn create_content_directory_service(client: Arc<RwLock<RadioParadiseClient>>) -> Service {
     let mut service = Service::new("ContentDirectory".to_string());
     service.set_service_type("urn:schemas-upnp-org:service:ContentDirectory:1".to_string());
     service.set_service_id("urn:upnp-org:serviceId:ContentDirectory".to_string());
 
     // State variables
-    let system_update_id = StateVariable::new(
-        "SystemUpdateID".to_string(),
-        "ui4".to_string(),
-    ).with_send_events(true)
-     .with_default_value("0".to_string());
+    let system_update_id = StateVariable::new("SystemUpdateID".to_string(), "ui4".to_string())
+        .with_send_events(true)
+        .with_default_value("0".to_string());
 
-    let container_update_ids = StateVariable::new(
-        "ContainerUpdateIDs".to_string(),
-        "string".to_string(),
-    ).with_send_events(true)
-     .with_default_value("".to_string());
+    let container_update_ids =
+        StateVariable::new("ContainerUpdateIDs".to_string(), "string".to_string())
+            .with_send_events(true)
+            .with_default_value("".to_string());
 
     service.add_state_variable(Arc::new(system_update_id));
     service.add_state_variable(Arc::new(container_update_ids));
@@ -37,11 +32,17 @@ pub fn create_content_directory_service(
     // Browse action
     let mut browse = Action::new("Browse".to_string());
     browse.add_input_argument("ObjectID".to_string(), "A_ARG_TYPE_ObjectID".to_string());
-    browse.add_input_argument("BrowseFlag".to_string(), "A_ARG_TYPE_BrowseFlag".to_string());
+    browse.add_input_argument(
+        "BrowseFlag".to_string(),
+        "A_ARG_TYPE_BrowseFlag".to_string(),
+    );
     browse.add_input_argument("Filter".to_string(), "A_ARG_TYPE_Filter".to_string());
     browse.add_input_argument("StartingIndex".to_string(), "A_ARG_TYPE_Index".to_string());
     browse.add_input_argument("RequestedCount".to_string(), "A_ARG_TYPE_Count".to_string());
-    browse.add_input_argument("SortCriteria".to_string(), "A_ARG_TYPE_SortCriteria".to_string());
+    browse.add_input_argument(
+        "SortCriteria".to_string(),
+        "A_ARG_TYPE_SortCriteria".to_string(),
+    );
     browse.add_output_argument("Result".to_string(), "A_ARG_TYPE_Result".to_string());
     browse.add_output_argument("NumberReturned".to_string(), "A_ARG_TYPE_Count".to_string());
     browse.add_output_argument("TotalMatches".to_string(), "A_ARG_TYPE_Count".to_string());
@@ -51,9 +52,7 @@ pub fn create_content_directory_service(
     let client_clone = client.clone();
     browse.set_handler(Box::new(move |args| {
         let client = client_clone.clone();
-        Box::pin(async move {
-            handle_browse(client, args).await
-        })
+        Box::pin(async move { handle_browse(client, args).await })
     }));
 
     service.add_action(Arc::new(browse));
@@ -75,10 +74,7 @@ pub fn create_content_directory_service(
 
     // GetSortCapabilities action
     let mut get_sort_caps = Action::new("GetSortCapabilities".to_string());
-    get_sort_caps.add_output_argument(
-        "SortCaps".to_string(),
-        "A_ARG_TYPE_SortCaps".to_string(),
-    );
+    get_sort_caps.add_output_argument("SortCaps".to_string(), "A_ARG_TYPE_SortCaps".to_string());
     get_sort_caps.set_handler(Box::new(|_| {
         Box::pin(async {
             let mut result = std::collections::HashMap::new();
@@ -101,40 +97,49 @@ pub fn create_content_directory_service(
     service.add_action(Arc::new(get_update_id));
 
     // Argument state variables
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_ObjectID".to_string(), "string".to_string())
-    ));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_ObjectID".to_string(),
+        "string".to_string(),
+    )));
     service.add_state_variable(Arc::new(
         StateVariable::new("A_ARG_TYPE_BrowseFlag".to_string(), "string".to_string())
             .with_allowed_values(vec![
                 "BrowseMetadata".to_string(),
                 "BrowseDirectChildren".to_string(),
-            ])
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_Filter".to_string(), "string".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_Index".to_string(), "ui4".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_Count".to_string(), "ui4".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_SortCriteria".to_string(), "string".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_Result".to_string(), "string".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_UpdateID".to_string(), "ui4".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_SearchCaps".to_string(), "string".to_string())
-    ));
-    service.add_state_variable(Arc::new(
-        StateVariable::new("A_ARG_TYPE_SortCaps".to_string(), "string".to_string())
+            ]),
     ));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_Filter".to_string(),
+        "string".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_Index".to_string(),
+        "ui4".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_Count".to_string(),
+        "ui4".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_SortCriteria".to_string(),
+        "string".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_Result".to_string(),
+        "string".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_UpdateID".to_string(),
+        "ui4".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_SearchCaps".to_string(),
+        "string".to_string(),
+    )));
+    service.add_state_variable(Arc::new(StateVariable::new(
+        "A_ARG_TYPE_SortCaps".to_string(),
+        "string".to_string(),
+    )));
 
     service
 }
@@ -146,10 +151,12 @@ async fn handle_browse(
 ) -> Result<std::collections::HashMap<String, String>, String> {
     let object_id = args.get("ObjectID").ok_or("Missing ObjectID")?;
     let browse_flag = args.get("BrowseFlag").ok_or("Missing BrowseFlag")?;
-    let starting_index: usize = args.get("StartingIndex")
+    let starting_index: usize = args
+        .get("StartingIndex")
         .and_then(|s| s.parse().ok())
         .unwrap_or(0);
-    let requested_count: usize = args.get("RequestedCount")
+    let requested_count: usize = args
+        .get("RequestedCount")
         .and_then(|s| s.parse().ok())
         .unwrap_or(100);
 
@@ -163,7 +170,9 @@ async fn handle_browse(
                 (serialize_didl(&[root]), 1, 1)
             } else {
                 // BrowseDirectChildren - show current block as a container
-                let block = client.get_block(None).await
+                let block = client
+                    .get_block(None)
+                    .await
                     .map_err(|e| format!("Failed to get block: {}", e))?;
 
                 let block_container = create_block_container(&block);
@@ -172,11 +181,14 @@ async fn handle_browse(
         }
         id if id.starts_with("block:") => {
             // Browse songs in a block
-            let event_id: u64 = id.strip_prefix("block:")
+            let event_id: u64 = id
+                .strip_prefix("block:")
                 .and_then(|s| s.parse().ok())
                 .ok_or("Invalid block ID")?;
 
-            let block = client.get_block(Some(event_id)).await
+            let block = client
+                .get_block(Some(event_id))
+                .await
                 .map_err(|e| format!("Failed to get block: {}", e))?;
 
             if browse_flag == "BrowseMetadata" {
@@ -186,12 +198,14 @@ async fn handle_browse(
                 // BrowseDirectChildren - show songs
                 let songs = block.songs_ordered();
                 let total = songs.len();
-                let songs_slice = songs.iter()
+                let songs_slice = songs
+                    .iter()
                     .skip(starting_index)
                     .take(requested_count)
                     .collect::<Vec<_>>();
 
-                let items: Vec<DIDLObject> = songs_slice.iter()
+                let items: Vec<DIDLObject> = songs_slice
+                    .iter()
                     .map(|(idx, song)| create_song_item(&block, *idx, song))
                     .collect();
 
@@ -224,11 +238,12 @@ fn create_root_container() -> DIDLObject {
 
 /// Create a container for a block
 fn create_block_container(block: &crate::models::Block) -> DIDLObject {
-    let mut container = DIDLContainer::new(
-        format!("block:{}", block.event),
-        "0".to_string(),
-    );
-    container.set_title(format!("Block {} ({} songs)", block.event, block.song_count()));
+    let mut container = DIDLContainer::new(format!("block:{}", block.event), "0".to_string());
+    container.set_title(format!(
+        "Block {} ({} songs)",
+        block.event,
+        block.song_count()
+    ));
     container.set_class("object.container.album.musicAlbum".to_string());
     container.set_searchable(false);
     container.set_child_count(Some(block.song_count()));
@@ -298,7 +313,9 @@ fn format_duration(duration_ms: u64) -> String {
 
 /// Serialize DIDL objects to XML string
 fn serialize_didl(objects: &[DIDLObject]) -> String {
-    let mut didl = String::from(r#"<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">"#);
+    let mut didl = String::from(
+        r#"<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">"#,
+    );
 
     for obj in objects {
         didl.push_str(&obj.to_didl());
diff --git a/pmoparadise/src/mediaserver/mod.rs b/pmoparadise/src/mediaserver/mod.rs
index c12b4330..d5335f38 100644
--- a/pmoparadise/src/mediaserver/mod.rs
+++ b/pmoparadise/src/mediaserver/mod.rs
@@ -48,11 +48,11 @@
 //! ```
 
 #[cfg(feature = "mediaserver")]
-mod server;
+mod connection_manager;
 #[cfg(feature = "mediaserver")]
 mod content_directory;
 #[cfg(feature = "mediaserver")]
-mod connection_manager;
+mod server;
 
 #[cfg(feature = "mediaserver")]
-pub use server::{RadioParadiseMediaServer, MediaServerBuilder};
+pub use server::{MediaServerBuilder, RadioParadiseMediaServer};
diff --git a/pmoparadise/src/mediaserver/server.rs b/pmoparadise/src/mediaserver/server.rs
index 7b55f7e4..2ed9aafc 100644
--- a/pmoparadise/src/mediaserver/server.rs
+++ b/pmoparadise/src/mediaserver/server.rs
@@ -3,9 +3,9 @@
 use crate::error::{Error, Result};
 use crate::models::Bitrate;
 use crate::RadioParadiseClient;
-use pmoupnp::devices::Device;
-use pmoupnp::{UpnpServer};
 use pmoserver::Server;
+use pmoupnp::devices::Device;
+use pmoupnp::UpnpServer;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
@@ -33,7 +33,9 @@ impl RadioParadiseMediaServer {
     ///
     /// This will start the HTTP server and SSDP announcements.
     pub async fn run(self) -> Result<()> {
-        self.server.run().await
+        self.server
+            .run()
+            .await
             .map_err(|e| Error::other(format!("Server error: {}", e)))
     }
 
@@ -144,19 +146,21 @@ impl MediaServerBuilder {
         device.set_udn(device_udn.clone());
 
         // Add ContentDirectory service
-        let content_directory = super::content_directory::create_content_directory_service(
-            client.clone()
-        );
-        device.add_service(Arc::new(content_directory))
+        let content_directory =
+            super::content_directory::create_content_directory_service(client.clone());
+        device
+            .add_service(Arc::new(content_directory))
             .map_err(|e| Error::other(format!("Failed to add ContentDirectory: {:?}", e)))?;
 
         // Add ConnectionManager service
         let connection_manager = super::connection_manager::create_connection_manager_service();
-        device.add_service(Arc::new(connection_manager))
+        device
+            .add_service(Arc::new(connection_manager))
             .map_err(|e| Error::other(format!("Failed to add ConnectionManager: {:?}", e)))?;
 
         // Register device with server
-        server.register_device(Arc::new(device))
+        server
+            .register_device(Arc::new(device))
             .await
             .map_err(|e| Error::other(format!("Failed to register device: {:?}", e)))?;
 
diff --git a/pmoparadise/src/models.rs b/pmoparadise/src/models.rs
index 3b422cd5..e7ec3ff4 100644
--- a/pmoparadise/src/models.rs
+++ b/pmoparadise/src/models.rs
@@ -270,7 +270,8 @@ pub struct Block {
 impl Block {
     /// Get songs in order by index
     pub fn songs_ordered(&self) -> Vec<(usize, &Song)> {
-        let mut songs: Vec<_> = self.song
+        let mut songs: Vec<_> = self
+            .song
             .iter()
             .filter_map(|(k, v)| k.parse::<usize>().ok().map(|idx| (idx, v)))
             .collect();
@@ -290,7 +291,9 @@ impl Block {
 
     /// Get the full URL for a cover image
     pub fn cover_url(&self, cover_path: &str) -> Option<String> {
-        self.image_base.as_ref().map(|base| format!("{}{}", base, cover_path))
+        self.image_base
+            .as_ref()
+            .map(|base| format!("{}{}", base, cover_path))
     }
 
     /// Find which song is playing at a given timestamp (ms from block start)
@@ -334,7 +337,8 @@ pub struct NowPlaying {
 impl NowPlaying {
     /// Create from a block (assumes starting from beginning)
     pub fn from_block(block: Block) -> Self {
-        let (current_song_index, current_song) = block.get_song(0)
+        let (current_song_index, current_song) = block
+            .get_song(0)
             .map(|s| (Some(0), Some(s.clone())))
             .unwrap_or((None, None));
 
diff --git a/pmoparadise/src/pmoserver_ext.rs b/pmoparadise/src/pmoserver_ext.rs
index e4536c34..a559676d 100644
--- a/pmoparadise/src/pmoserver_ext.rs
+++ b/pmoparadise/src/pmoserver_ext.rs
@@ -3,7 +3,7 @@
 //! Ce module fournit un trait d'extension pour ajouter facilement l'API Radio Paradise
 //! à un serveur pmoserver.
 
-use crate::{RadioParadiseClient, Block, NowPlaying};
+use crate::{Block, NowPlaying, RadioParadiseClient};
 use axum::{
     extract::{Path, State},
     http::StatusCode,
@@ -188,13 +188,10 @@ async fn get_now_playing(
     State(state): State<RadioParadiseState>,
 ) -> Result<Json<NowPlayingResponse>, StatusCode> {
     let client = state.client.read().await;
-    let now_playing = client
-        .now_playing()
-        .await
-        .map_err(|e| {
-            tracing::error!("Failed to fetch now playing from Radio Paradise: {}", e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
+    let now_playing = client.now_playing().await.map_err(|e| {
+        tracing::error!("Failed to fetch now playing from Radio Paradise: {}", e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
 
     Ok(Json(now_playing.into()))
 }
@@ -213,13 +210,10 @@ async fn get_current_block(
     State(state): State<RadioParadiseState>,
 ) -> Result<Json<BlockResponse>, StatusCode> {
     let client = state.client.read().await;
-    let block = client
-        .get_block(None)
-        .await
-        .map_err(|e| {
-            tracing::error!("Failed to fetch current block from Radio Paradise: {}", e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
+    let block = client.get_block(None).await.map_err(|e| {
+        tracing::error!("Failed to fetch current block from Radio Paradise: {}", e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
 
     Ok(Json(block.into()))
 }
@@ -242,13 +236,14 @@ async fn get_block_by_id(
     Path(event_id): Path<u64>,
 ) -> Result<Json<BlockResponse>, StatusCode> {
     let client = state.client.read().await;
-    let block = client
-        .get_block(Some(event_id))
-        .await
-        .map_err(|e| {
-            tracing::error!("Failed to fetch block {} from Radio Paradise: {}", event_id, e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
+    let block = client.get_block(Some(event_id)).await.map_err(|e| {
+        tracing::error!(
+            "Failed to fetch block {} from Radio Paradise: {}",
+            event_id,
+            e
+        );
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
 
     Ok(Json(block.into()))
 }
@@ -396,11 +391,8 @@ impl RadioParadiseExt for pmoserver::Server {
         let api_router = create_api_router(state.clone());
 
         // L'enregistrer avec OpenAPI
-        self.add_openapi(
-            api_router,
-            RadioParadiseApiDoc::openapi(),
-            "radioparadise"
-        ).await;
+        self.add_openapi(api_router, RadioParadiseApiDoc::openapi(), "radioparadise")
+            .await;
 
         Ok(state)
     }
diff --git a/pmoparadise/src/source.rs b/pmoparadise/src/source.rs
index 7db8a0e1..82ee3e97 100644
--- a/pmoparadise/src/source.rs
+++ b/pmoparadise/src/source.rs
@@ -5,12 +5,12 @@
 
 use crate::client::RadioParadiseClient;
 use crate::models::{Block, Song};
-use pmosource::{async_trait, pmodidl, BrowseResult, MusicSource, MusicSourceError, Result};
-use pmosource::SourceCacheManager;
 use pmoaudiocache::{AudioMetadata, Cache as AudioCache};
 use pmocovers::Cache as CoverCache;
 use pmodidl::{Container, Item, Resource};
 use pmoplaylist::{FifoPlaylist, Track};
+use pmosource::SourceCacheManager;
+use pmosource::{async_trait, pmodidl, BrowseResult, MusicSource, MusicSourceError, Result};
 use std::sync::Arc;
 use std::time::SystemTime;
 
@@ -73,8 +73,7 @@ struct RadioParadiseSourceInner {
 
 impl std::fmt::Debug for RadioParadiseSource {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("RadioParadiseSource")
-            .finish()
+        f.debug_struct("RadioParadiseSource").finish()
     }
 }
 
@@ -140,11 +139,8 @@ impl RadioParadiseSource {
             DEFAULT_IMAGE,
         );
 
-        let cache_manager = SourceCacheManager::new(
-            "radio-paradise".to_string(),
-            cover_cache,
-            audio_cache,
-        );
+        let cache_manager =
+            SourceCacheManager::new("radio-paradise".to_string(), cover_cache, audio_cache);
 
         Self {
             inner: Arc::new(RadioParadiseSourceInner {
@@ -248,7 +244,12 @@ impl RadioParadiseSource {
             bitrate: None,
         };
 
-        let cached_audio_pk = match self.inner.cache_manager.cache_audio(&block.url, Some(metadata)).await {
+        let cached_audio_pk = match self
+            .inner
+            .cache_manager
+            .cache_audio(&block.url, Some(metadata))
+            .await
+        {
             Ok(pk) => {
                 tracing::info!("Successfully cached audio for track {}: {}", track_id, pk);
                 Some(pk)
@@ -260,14 +261,17 @@ impl RadioParadiseSource {
         };
 
         // 3. Store metadata in the cache manager
-        self.inner.cache_manager.update_metadata(
-            track_id.clone(),
-            pmosource::TrackMetadata {
-                original_uri: block.url.clone(),
-                cached_audio_pk,
-                cached_cover_pk,
-            }
-        ).await;
+        self.inner
+            .cache_manager
+            .update_metadata(
+                track_id.clone(),
+                pmosource::TrackMetadata {
+                    original_uri: block.url.clone(),
+                    cached_audio_pk,
+                    cached_cover_pk,
+                },
+            )
+            .await;
 
         // 4. Store block for later retrieval
         {
@@ -362,7 +366,10 @@ impl MusicSource for RadioParadiseSource {
                             }
                         }
 
-                        tracing::info!("✅ Added {} tracks to Radio Paradise FIFO", block.song_count());
+                        tracing::info!(
+                            "✅ Added {} tracks to Radio Paradise FIFO",
+                            block.song_count()
+                        );
                     }
                     Err(e) => {
                         tracing::warn!("Failed to fetch current tracks: {}", e);
@@ -544,21 +551,35 @@ impl MusicSource for RadioParadiseSource {
         }
 
         // Get metadata and block info
-        let metadata = self.inner.cache_manager.get_metadata(object_id).await
+        let metadata = self
+            .inner
+            .cache_manager
+            .get_metadata(object_id)
+            .await
             .ok_or_else(|| MusicSourceError::ObjectNotFound(object_id.to_string()))?;
 
         let blocks = self.inner.blocks.read().await;
-        let (block, song_index) = blocks.get(object_id)
+        let (block, song_index) = blocks
+            .get(object_id)
             .ok_or_else(|| MusicSourceError::ObjectNotFound(object_id.to_string()))?;
-        let song = block.get_song(*song_index)
-            .ok_or_else(|| MusicSourceError::ObjectNotFound(format!("Song {} not found", object_id)))?;
+        let song = block.get_song(*song_index).ok_or_else(|| {
+            MusicSourceError::ObjectNotFound(format!("Song {} not found", object_id))
+        })?;
 
         // Prepare metadata
         let audio_metadata = AudioMetadata {
             title: Some(song.title.clone()),
-            artist: if !song.artist.is_empty() { Some(song.artist.clone()) } else { None },
+            artist: if !song.artist.is_empty() {
+                Some(song.artist.clone())
+            } else {
+                None
+            },
             album: song.album.clone().filter(|a| !a.is_empty()),
-            duration_secs: if song.duration > 0 { Some((song.duration / 1000) as u64) } else { None },
+            duration_secs: if song.duration > 0 {
+                Some((song.duration / 1000) as u64)
+            } else {
+                None
+            },
             year: None,
             track_number: None,
             track_total: None,
@@ -571,15 +592,25 @@ impl MusicSource for RadioParadiseSource {
         };
 
         // Cache via manager
-        match self.inner.cache_manager.cache_audio(&metadata.original_uri, Some(audio_metadata)).await {
+        match self
+            .inner
+            .cache_manager
+            .cache_audio(&metadata.original_uri, Some(audio_metadata))
+            .await
+        {
             Ok(pk) => {
                 // Update metadata with new pk
                 let mut updated = metadata;
                 updated.cached_audio_pk = Some(pk);
-                self.inner.cache_manager.update_metadata(object_id.to_string(), updated).await;
+                self.inner
+                    .cache_manager
+                    .update_metadata(object_id.to_string(), updated)
+                    .await;
                 self.get_cache_status(object_id).await
             }
-            Err(e) => Ok(CacheStatus::Failed { error: e.to_string() }),
+            Err(e) => Ok(CacheStatus::Failed {
+                error: e.to_string(),
+            }),
         }
     }
 
@@ -631,14 +662,10 @@ mod tests {
         std::fs::create_dir_all(&cover_dir).ok();
         std::fs::create_dir_all(&audio_dir).ok();
 
-        let cover_cache = Arc::new(
-            pmocovers::Cache::new(cover_dir.to_str().unwrap(), 100)
-                .unwrap()
-        );
-        let audio_cache = Arc::new(
-            pmoaudiocache::new_cache(audio_dir.to_str().unwrap(), 100)
-                .unwrap()
-        );
+        let cover_cache =
+            Arc::new(pmocovers::Cache::new(cover_dir.to_str().unwrap(), 100).unwrap());
+        let audio_cache =
+            Arc::new(pmoaudiocache::new_cache(audio_dir.to_str().unwrap(), 100).unwrap());
 
         (cover_cache, audio_cache)
     }
@@ -647,11 +674,7 @@ mod tests {
     async fn test_source_info() {
         let client = RadioParadiseClient::with_client(reqwest::Client::new());
         let (cover_cache, audio_cache) = create_test_caches().await;
-        let source = RadioParadiseSource::new_default(
-            client,
-            cover_cache,
-            audio_cache
-        );
+        let source = RadioParadiseSource::new_default(client, cover_cache, audio_cache);
 
         assert_eq!(source.name(), "Radio Paradise");
         assert_eq!(source.id(), "radio-paradise");
@@ -664,7 +687,10 @@ mod tests {
         assert!(DEFAULT_IMAGE.len() > 0, "Default image should not be empty");
 
         // Check WebP magic bytes (RIFF...WEBP)
-        assert!(DEFAULT_IMAGE.len() >= 12, "Image too small to be valid WebP");
+        assert!(
+            DEFAULT_IMAGE.len() >= 12,
+            "Image too small to be valid WebP"
+        );
         assert_eq!(&DEFAULT_IMAGE[0..4], b"RIFF", "Missing RIFF header");
         assert_eq!(&DEFAULT_IMAGE[8..12], b"WEBP", "Missing WEBP signature");
     }
@@ -673,11 +699,7 @@ mod tests {
     async fn test_fifo_operations() {
         let client = RadioParadiseClient::with_client(reqwest::Client::new());
         let (cover_cache, audio_cache) = create_test_caches().await;
-        let source = RadioParadiseSource::new_default(
-            client,
-            cover_cache,
-            audio_cache
-        );
+        let source = RadioParadiseSource::new_default(client, cover_cache, audio_cache);
 
         // Initially empty
         let items = source.get_items(0, 10).await.unwrap();
diff --git a/pmoparadise/src/stream.rs b/pmoparadise/src/stream.rs
index 75d89759..25456280 100644
--- a/pmoparadise/src/stream.rs
+++ b/pmoparadise/src/stream.rs
@@ -70,7 +70,8 @@ impl RadioParadiseClient {
         #[cfg(feature = "logging")]
         tracing::debug!("Starting block stream: {}", block_url);
 
-        let response = self.client
+        let response = self
+            .client
             .get(block_url.clone())
             .timeout(self.timeout)
             .send()
@@ -85,9 +86,7 @@ impl RadioParadiseClient {
 
         // Convert reqwest's byte stream to our Result type
         let stream = response.bytes_stream();
-        let mapped = futures::stream::StreamExt::map(stream, |result| {
-            result.map_err(Error::from)
-        });
+        let mapped = futures::stream::StreamExt::map(stream, |result| result.map_err(Error::from));
 
         Ok(BlockStream::new(mapped))
     }
@@ -149,7 +148,8 @@ impl RadioParadiseClient {
         #[cfg(feature = "logging")]
         tracing::debug!("Downloading complete block: {}", block_url);
 
-        let response = self.client
+        let response = self
+            .client
             .get(block_url.clone())
             .timeout(self.timeout)
             .send()
diff --git a/pmoparadise/src/track.rs b/pmoparadise/src/track.rs
index 855f7745..8cab4c44 100644
--- a/pmoparadise/src/track.rs
+++ b/pmoparadise/src/track.rs
@@ -97,11 +97,14 @@ impl TrackStream {
         track_index: usize,
     ) -> Result<Self> {
         // Validate track index
-        let song = block.get_song(track_index)
+        let song = block
+            .get_song(track_index)
             .ok_or(Error::InvalidIndex(track_index, block.song_count()))?;
 
         // Download block to temporary file
-        let url = block.url.parse()
+        let url = block
+            .url
+            .parse()
             .map_err(|e| Error::other(format!("Invalid block URL: {}", e)))?;
 
         let block_data = client.download_block(&url).await?;
@@ -191,7 +194,9 @@ impl TrackStream {
     /// Returns samples as 16-bit signed integers (i16), interleaved by channel.
     /// For stereo: [L, R, L, R, ...]. Returns None when track ends.
     pub fn read_samples(&mut self, buffer: &mut [i16]) -> Result<Option<usize>> {
-        let reader = self.reader.as_mut()
+        let reader = self
+            .reader
+            .as_mut()
             .ok_or(Error::other("TrackStream already consumed"))?;
 
         let mut samples_iter = reader.samples();
@@ -335,7 +340,11 @@ impl RadioParadiseClient {
     /// # }
     /// # }
     /// ```
-    pub async fn open_track_stream(&self, block: &Block, track_index: usize) -> Result<TrackStream> {
+    pub async fn open_track_stream(
+        &self,
+        block: &Block,
+        track_index: usize,
+    ) -> Result<TrackStream> {
         TrackStream::from_block_internal(self, block, track_index).await
     }
 
@@ -363,7 +372,8 @@ impl RadioParadiseClient {
     /// # }
     /// ```
     pub fn track_position_seconds(&self, block: &Block, track_index: usize) -> Result<(f64, f64)> {
-        let song = block.get_song(track_index)
+        let song = block
+            .get_song(track_index)
             .ok_or(Error::InvalidIndex(track_index, block.song_count()))?;
 
         let start_secs = song.elapsed as f64 / 1000.0;
diff --git a/pmoplaylist/examples/basic_usage.rs b/pmoplaylist/examples/basic_usage.rs
index 33c02b2c..1671186d 100644
--- a/pmoplaylist/examples/basic_usage.rs
+++ b/pmoplaylist/examples/basic_usage.rs
@@ -5,7 +5,7 @@
 //! cargo run -p pmoplaylist --example basic_usage
 //! ```
 
-use pmoplaylist::{FifoPlaylist, Track, DEFAULT_IMAGE};
+use pmoplaylist::{DEFAULT_IMAGE, FifoPlaylist, Track};
 
 #[tokio::main]
 async fn main() {
@@ -27,26 +27,40 @@ async fn main() {
     // 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),
+        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!(
+            "   ✓ Ajouté: {} - {}",
+            track.title,
+            track.artist.unwrap_or_default()
+        );
     }
 
     println!("\n   Total tracks: {}", playlist.len().await);
@@ -60,12 +74,15 @@ async fn main() {
         let track = Track::new(
             format!("track-{}", i),
             format!("Song Number {}", i),
-            format!("http://example.com/songs/{}.mp3", i)
+            format!("http://example.com/songs/{}.mp3", i),
         );
         playlist.append_track(track).await;
     }
 
-    println!("   ✓ Total tracks (limité par capacité): {}", playlist.len().await);
+    println!(
+        "   ✓ Total tracks (limité par capacité): {}",
+        playlist.len().await
+    );
 
     // Afficher les tracks actuels
     let items = playlist.get_items(0, 10).await;
@@ -99,15 +116,16 @@ async fn main() {
     println!("     - Parent ID: {}", container.parent_id);
     println!("     - Title: {}", container.title);
     println!("     - Class: {}", container.class);
-    println!("     - Child Count: {}\n", container.child_count.unwrap_or_default());
+    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;
+    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() {
@@ -134,7 +152,10 @@ async fn main() {
     // 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!(
+        "   ✓ 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
diff --git a/pmoplaylist/examples/http_server_integration.rs b/pmoplaylist/examples/http_server_integration.rs
index 6a33dd61..d4aab310 100644
--- a/pmoplaylist/examples/http_server_integration.rs
+++ b/pmoplaylist/examples/http_server_integration.rs
@@ -8,7 +8,7 @@
 //! cargo run -p pmoplaylist --example http_server_integration
 //! ```
 
-use pmoplaylist::{FifoPlaylist, Track, DEFAULT_IMAGE};
+use pmoplaylist::{DEFAULT_IMAGE, FifoPlaylist, Track};
 use std::sync::Arc;
 
 #[tokio::main]
@@ -35,17 +35,19 @@ async fn main() {
     ];
 
     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)
+        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)),
             )
-            .with_artist(*artist)
-            .with_album(*album)
-            .with_duration(*duration)
-            .with_image(format!("http://media.server/covers/{}.jpg", idx))
-        ).await;
+            .await;
         println!("  ✓ {} - {}", artist, title);
     }
     println!();
@@ -72,7 +74,7 @@ async fn main() {
     let new_track = Track::new(
         "track-new-1",
         "Stairway to Heaven",
-        "http://media.server/music/stairway.flac"
+        "http://media.server/music/stairway.flac",
     )
     .with_artist("Led Zeppelin")
     .with_album("Led Zeppelin IV")
@@ -115,17 +117,18 @@ async fn simulate_get_container(playlist: Arc<FifoPlaylist>) {
     println!("    \"parentId\": \"{}\",", container.parent_id);
     println!("    \"title\": \"{}\",", container.title);
     println!("    \"class\": \"{}\",", container.class);
-    println!("    \"childCount\": {}", container.child_count.unwrap_or_default());
+    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;
+    let items = playlist
+        .as_objects(offset, count, Some("http://media.server/api/default-image"))
+        .await;
 
     println!("  Response: {} items", items.len());
     println!("  [");
@@ -133,8 +136,14 @@ async fn simulate_get_items(playlist: Arc<FifoPlaylist>, offset: usize, count: u
         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!(
+            "      \"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);
@@ -175,7 +184,8 @@ async fn simulate_add_track(playlist: Arc<FifoPlaylist>, track: Track) {
 
     let new_update_id = playlist.update_id().await;
 
-    println!("  Track added: {} - {}",
+    println!(
+        "  Track added: {} - {}",
         track.artist.as_deref().unwrap_or("Unknown"),
         track.title
     );
diff --git a/pmoplaylist/examples/radio_streaming.rs b/pmoplaylist/examples/radio_streaming.rs
index d15d511e..69d4ae54 100644
--- a/pmoplaylist/examples/radio_streaming.rs
+++ b/pmoplaylist/examples/radio_streaming.rs
@@ -10,7 +10,7 @@
 //! cargo run -p pmoplaylist --example radio_streaming
 //! ```
 
-use pmoplaylist::{FifoPlaylist, Track, DEFAULT_IMAGE};
+use pmoplaylist::{DEFAULT_IMAGE, FifoPlaylist, Track};
 use std::time::Duration;
 use tokio::time::sleep;
 
@@ -42,26 +42,46 @@ async fn main() {
         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),
+            (
+                "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),
+            (
+                "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),
+            (
+                "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),
+            (
+                "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)
+                format!("http://stream.radioparadise.com/track/{}", idx),
             )
             .with_artist(*artist)
             .with_album(*album)
@@ -94,9 +114,7 @@ async fn main() {
             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, count
                 );
                 last_update_id = current_update_id;
             }
@@ -125,7 +143,11 @@ async fn main() {
             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!(
+                "📱 [CLIENT] Consultation #{} (Update ID: {})",
+                i + 1,
+                update_id
+            );
             println!("   Historique actuel ({} tracks):", history.len());
 
             for (idx, track) in history.iter().enumerate() {
@@ -140,7 +162,10 @@ async fn main() {
         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!(
+            "   Child Count: {}",
+            container.child_count.unwrap_or_default()
+        );
 
         println!("\n📱 [CLIENT] Fin de la consultation");
     });
diff --git a/pmoplaylist/src/lib.rs b/pmoplaylist/src/lib.rs
index fb7a827b..b55d507b 100644
--- a/pmoplaylist/src/lib.rs
+++ b/pmoplaylist/src/lib.rs
@@ -229,12 +229,7 @@ impl FifoPlaylist {
     ///     pmoplaylist::DEFAULT_IMAGE,
     /// );
     /// ```
-    pub fn new(
-        id: String,
-        title: String,
-        capacity: usize,
-        default_image: &'static [u8],
-    ) -> Self {
+    pub fn new(id: String, title: String, capacity: usize, default_image: &'static [u8]) -> Self {
         Self {
             inner: Arc::new(RwLock::new(FifoPlaylistInner {
                 id,
@@ -414,7 +409,8 @@ impl FifoPlaylist {
     pub async fn get_items(&self, offset: usize, count: usize) -> Vec<Track> {
         let inner = self.inner.read().await;
 
-        inner.queue
+        inner
+            .queue
             .iter()
             .skip(offset)
             .take(count)
@@ -531,7 +527,8 @@ impl FifoPlaylist {
     ) -> Vec<Item> {
         let inner = self.inner.read().await;
 
-        inner.queue
+        inner
+            .queue
             .iter()
             .skip(offset)
             .take(count)
@@ -618,8 +615,12 @@ mod tests {
             DEFAULT_IMAGE,
         );
 
-        playlist.append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3")).await;
-        playlist.append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3")).await;
+        playlist
+            .append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3"))
+            .await;
+        playlist
+            .append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3"))
+            .await;
 
         let removed = playlist.remove_oldest().await;
         assert!(removed.is_some());
@@ -636,9 +637,15 @@ mod tests {
             DEFAULT_IMAGE,
         );
 
-        playlist.append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3")).await;
-        playlist.append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3")).await;
-        playlist.append_track(Track::new("track-3", "Song 3", "http://example.com/3.mp3")).await;
+        playlist
+            .append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3"))
+            .await;
+        playlist
+            .append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3"))
+            .await;
+        playlist
+            .append_track(Track::new("track-3", "Song 3", "http://example.com/3.mp3"))
+            .await;
 
         assert!(playlist.remove_by_id("track-2").await);
         assert_eq!(playlist.len().await, 2);
@@ -657,8 +664,12 @@ mod tests {
             DEFAULT_IMAGE,
         );
 
-        playlist.append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3")).await;
-        playlist.append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3")).await;
+        playlist
+            .append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3"))
+            .await;
+        playlist
+            .append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3"))
+            .await;
 
         playlist.clear().await;
         assert_eq!(playlist.len().await, 0);
@@ -675,11 +686,13 @@ mod tests {
         );
 
         for i in 0..5 {
-            playlist.append_track(Track::new(
-                format!("track-{}", i),
-                format!("Song {}", i),
-                format!("http://example.com/{}.mp3", i),
-            )).await;
+            playlist
+                .append_track(Track::new(
+                    format!("track-{}", i),
+                    format!("Song {}", i),
+                    format!("http://example.com/{}.mp3", i),
+                ))
+                .await;
         }
 
         let items = playlist.get_items(1, 2).await;
@@ -697,7 +710,9 @@ mod tests {
             DEFAULT_IMAGE,
         );
 
-        playlist.append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3")).await;
+        playlist
+            .append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3"))
+            .await;
 
         let container = playlist.as_container().await;
         assert_eq!(container.id, "radio-1");
@@ -715,14 +730,20 @@ mod tests {
             DEFAULT_IMAGE,
         );
 
-        let track = Track::new("track-1", "Bohemian Rhapsody", "http://example.com/song.mp3")
-            .with_artist("Queen")
-            .with_album("A Night at the Opera")
-            .with_duration(354);
+        let track = Track::new(
+            "track-1",
+            "Bohemian Rhapsody",
+            "http://example.com/song.mp3",
+        )
+        .with_artist("Queen")
+        .with_album("A Night at the Opera")
+        .with_duration(354);
 
         playlist.append_track(track).await;
 
-        let items = playlist.as_objects(0, 10, Some("http://server/default.webp")).await;
+        let items = playlist
+            .as_objects(0, 10, Some("http://server/default.webp"))
+            .await;
         assert_eq!(items.len(), 1);
 
         let item = &items[0];
@@ -745,7 +766,10 @@ mod tests {
         assert_eq!(track.artist, Some("Artist".to_string()));
         assert_eq!(track.album, Some("Album".to_string()));
         assert_eq!(track.duration, Some(180));
-        assert_eq!(track.image, Some("http://example.com/cover.jpg".to_string()));
+        assert_eq!(
+            track.image,
+            Some("http://example.com/cover.jpg".to_string())
+        );
     }
 
     #[tokio::test]
@@ -759,10 +783,14 @@ mod tests {
 
         assert_eq!(playlist.update_id().await, 0);
 
-        playlist.append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3")).await;
+        playlist
+            .append_track(Track::new("track-1", "Song 1", "http://example.com/1.mp3"))
+            .await;
         assert_eq!(playlist.update_id().await, 1);
 
-        playlist.append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3")).await;
+        playlist
+            .append_track(Track::new("track-2", "Song 2", "http://example.com/2.mp3"))
+            .await;
         assert_eq!(playlist.update_id().await, 2);
 
         playlist.remove_oldest().await;
diff --git a/pmoqobuz/examples/basic_usage.rs b/pmoqobuz/examples/basic_usage.rs
index 2b628052..2d824494 100644
--- a/pmoqobuz/examples/basic_usage.rs
+++ b/pmoqobuz/examples/basic_usage.rs
@@ -58,7 +58,10 @@ async fn main() -> anyhow::Result<()> {
             println!(
                 "  {}. {} - {} ({}:{})",
                 track.track_number,
-                track.display_artist().map(|a| a.name.as_str()).unwrap_or("Unknown"),
+                track
+                    .display_artist()
+                    .map(|a| a.name.as_str())
+                    .unwrap_or("Unknown"),
                 track.title,
                 track.duration / 60,
                 track.duration % 60
diff --git a/pmoqobuz/examples/server_with_covers.rs b/pmoqobuz/examples/server_with_covers.rs
index 4362e1b5..d96d1ea6 100644
--- a/pmoqobuz/examples/server_with_covers.rs
+++ b/pmoqobuz/examples/server_with_covers.rs
@@ -50,7 +50,9 @@ async fn main() -> anyhow::Result<()> {
     println!("\n2. Initialisation du client Qobuz avec intégration pmocovers...");
     // Initialiser le client Qobuz avec intégration pmocovers
     // Les images d'albums seront automatiquement ajoutées au cache
-    let client = server.init_qobuz_client_configured_with_covers(cache.clone()).await?;
+    let client = server
+        .init_qobuz_client_configured_with_covers(cache.clone())
+        .await?;
 
     if let Some(auth_info) = client.auth_info() {
         println!("   ✓ Client Qobuz connecté !");
diff --git a/pmoqobuz/examples/show_source_image.rs b/pmoqobuz/examples/show_source_image.rs
index 7a48e80b..20e62ac2 100644
--- a/pmoqobuz/examples/show_source_image.rs
+++ b/pmoqobuz/examples/show_source_image.rs
@@ -5,7 +5,7 @@
 //! - Accessing the embedded WebP image
 //! - Optionally saving it to a file
 
-use pmoqobuz::{QobuzSource, QobuzClient};
+use pmoqobuz::{QobuzClient, QobuzSource};
 use pmosource::MusicSource;
 use std::fs;
 use std::io::Write;
diff --git a/pmoqobuz/examples/with_cache.rs b/pmoqobuz/examples/with_cache.rs
index 24af8aa2..82e1689d 100644
--- a/pmoqobuz/examples/with_cache.rs
+++ b/pmoqobuz/examples/with_cache.rs
@@ -8,9 +8,9 @@
 //! cargo run --example with_cache --features cache
 //! ```
 
-use pmoqobuz::{QobuzClient, QobuzSource};
-use pmocovers::Cache as CoverCache;
 use pmoaudiocache::AudioCache;
+use pmocovers::Cache as CoverCache;
+use pmoqobuz::{QobuzClient, QobuzSource};
 use pmosource::MusicSource;
 use std::sync::Arc;
 
@@ -60,9 +60,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         if !search_results.tracks.is_empty() {
             println!("\n📋 Found {} tracks:", search_results.tracks.len());
             for (i, track) in search_results.tracks.iter().enumerate().take(3) {
-                println!("   {}. {} - {}",
+                println!(
+                    "   {}. {} - {}",
                     i + 1,
-                    track.performer.as_ref().map(|p| p.name.as_str()).unwrap_or("Unknown"),
+                    track
+                        .performer
+                        .as_ref()
+                        .map(|p| p.name.as_str())
+                        .unwrap_or("Unknown"),
                     track.title
                 );
 
@@ -86,9 +91,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         // Add first 3 favorite tracks with caching
         for (i, track) in favorite_tracks.iter().enumerate().take(3) {
-            println!("{}. {} - {}",
+            println!(
+                "{}. {} - {}",
                 i + 1,
-                track.performer.as_ref().map(|p| p.name.as_str()).unwrap_or("Unknown"),
+                track
+                    .performer
+                    .as_ref()
+                    .map(|p| p.name.as_str())
+                    .unwrap_or("Unknown"),
                 track.title
             );
 
diff --git a/pmoqobuz/src/api/auth.rs b/pmoqobuz/src/api/auth.rs
index 1d8ddc6a..550b29f4 100644
--- a/pmoqobuz/src/api/auth.rs
+++ b/pmoqobuz/src/api/auth.rs
@@ -69,10 +69,7 @@ impl QobuzApi {
     pub async fn login(&mut self, username: &str, password: &str) -> Result<AuthInfo> {
         info!("Attempting to login to Qobuz as {}", username);
 
-        let params = [
-            ("username", username),
-            ("password", password),
-        ];
+        let params = [("username", username), ("password", password)];
 
         let response: LoginResponse = self.post("/user/login", &params).await?;
 
diff --git a/pmoqobuz/src/api/catalog.rs b/pmoqobuz/src/api/catalog.rs
index d9cf403e..edde18ad 100644
--- a/pmoqobuz/src/api/catalog.rs
+++ b/pmoqobuz/src/api/catalog.rs
@@ -257,7 +257,12 @@ impl QobuzApi {
 
         let response: SimilarArtistsResponse =
             self.get("/artist/getSimilarArtists", &params).await?;
-        Ok(response.artists.items.into_iter().map(Self::parse_artist).collect())
+        Ok(response
+            .artists
+            .items
+            .into_iter()
+            .map(Self::parse_artist)
+            .collect())
     }
 
     /// Récupère les détails d'une playlist
@@ -275,7 +280,11 @@ impl QobuzApi {
         let response: PlaylistResponse = self.get("/playlist/get", &params).await?;
 
         if let Some(tracks) = response.tracks {
-            Ok(tracks.items.into_iter().map(|t| Self::parse_track(t, None)).collect())
+            Ok(tracks
+                .items
+                .into_iter()
+                .map(|t| Self::parse_track(t, None))
+                .collect())
         } else {
             Ok(Vec::new())
         }
@@ -285,7 +294,12 @@ impl QobuzApi {
     pub async fn get_genres(&self) -> Result<Vec<Genre>> {
         debug!("Fetching genres");
         let response: GenresResponse = self.get("/genre/list", &[]).await?;
-        Ok(response.genres.items.into_iter().map(Self::parse_genre).collect())
+        Ok(response
+            .genres
+            .items
+            .into_iter()
+            .map(Self::parse_genre)
+            .collect())
     }
 
     /// Récupère les albums featured (nouveautés, éditeur, etc.)
@@ -329,7 +343,12 @@ impl QobuzApi {
 
         let response: FeaturedPlaylistsResponse =
             self.get("/playlist/getFeatured", &params).await?;
-        Ok(response.playlists.items.into_iter().map(Self::parse_playlist).collect())
+        Ok(response
+            .playlists
+            .items
+            .into_iter()
+            .map(Self::parse_playlist)
+            .collect())
     }
 
     /// Recherche dans le catalogue
@@ -391,10 +410,7 @@ impl QobuzApi {
             description: response.description,
             maximum_sampling_rate: response.maximum_sampling_rate,
             maximum_bit_depth: response.maximum_bit_depth,
-            genres: response
-                .genre
-                .map(|g| vec![g.name])
-                .unwrap_or_default(),
+            genres: response.genre.map(|g| vec![g.name]).unwrap_or_default(),
             label: response.label.map(|l| l.name),
         }
     }
diff --git a/pmoqobuz/src/api/mod.rs b/pmoqobuz/src/api/mod.rs
index 43550829..be144a3f 100644
--- a/pmoqobuz/src/api/mod.rs
+++ b/pmoqobuz/src/api/mod.rs
@@ -36,7 +36,9 @@ impl QobuzApi {
     pub fn new(app_id: impl Into<String>) -> Result<Self> {
         let client = Client::builder()
             .timeout(Duration::from_secs(30))
-            .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0")
+            .user_agent(
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0",
+            )
             .build()?;
 
         Ok(Self {
diff --git a/pmoqobuz/src/api/user.rs b/pmoqobuz/src/api/user.rs
index 115ab999..bd9dcd6e 100644
--- a/pmoqobuz/src/api/user.rs
+++ b/pmoqobuz/src/api/user.rs
@@ -64,11 +64,7 @@ impl QobuzApi {
         let user_id = self.ensure_authenticated()?;
         debug!("Fetching favorite artists for user {}", user_id);
 
-        let params = [
-            ("user_id", user_id),
-            ("type", "artists"),
-            ("limit", "1000"),
-        ];
+        let params = [("user_id", user_id), ("type", "artists"), ("limit", "1000")];
 
         let response: FavoritesResponse = self.get("/favorite/getUserFavorites", &params).await?;
 
@@ -125,70 +121,75 @@ impl QobuzApi {
     /// Ajoute un album aux favoris
     pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> {
         let user_id = self.ensure_authenticated()?;
-        debug!("Adding album {} to favorites for user {}", album_id, user_id);
+        debug!(
+            "Adding album {} to favorites for user {}",
+            album_id, user_id
+        );
 
-        let params = [
-            ("album_id", album_id),
-            ("user_id", user_id),
-        ];
+        let params = [("album_id", album_id), ("user_id", user_id)];
 
-        self.get::<serde_json::Value>("/favorite/create", &params).await?;
+        self.get::<serde_json::Value>("/favorite/create", &params)
+            .await?;
         Ok(())
     }
 
     /// Supprime un album des favoris
     pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> {
         let user_id = self.ensure_authenticated()?;
-        debug!("Removing album {} from favorites for user {}", album_id, user_id);
+        debug!(
+            "Removing album {} from favorites for user {}",
+            album_id, user_id
+        );
 
-        let params = [
-            ("album_ids", album_id),
-            ("user_id", user_id),
-        ];
+        let params = [("album_ids", album_id), ("user_id", user_id)];
 
-        self.get::<serde_json::Value>("/favorite/delete", &params).await?;
+        self.get::<serde_json::Value>("/favorite/delete", &params)
+            .await?;
         Ok(())
     }
 
     /// Ajoute un track aux favoris
     pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> {
         let user_id = self.ensure_authenticated()?;
-        debug!("Adding track {} to favorites for user {}", track_id, user_id);
+        debug!(
+            "Adding track {} to favorites for user {}",
+            track_id, user_id
+        );
 
-        let params = [
-            ("track_id", track_id),
-            ("user_id", user_id),
-        ];
+        let params = [("track_id", track_id), ("user_id", user_id)];
 
-        self.get::<serde_json::Value>("/favorite/create", &params).await?;
+        self.get::<serde_json::Value>("/favorite/create", &params)
+            .await?;
         Ok(())
     }
 
     /// Supprime un track des favoris
     pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> {
         let user_id = self.ensure_authenticated()?;
-        debug!("Removing track {} from favorites for user {}", track_id, user_id);
+        debug!(
+            "Removing track {} from favorites for user {}",
+            track_id, user_id
+        );
 
-        let params = [
-            ("track_ids", track_id),
-            ("user_id", user_id),
-        ];
+        let params = [("track_ids", track_id), ("user_id", user_id)];
 
-        self.get::<serde_json::Value>("/favorite/delete", &params).await?;
+        self.get::<serde_json::Value>("/favorite/delete", &params)
+            .await?;
         Ok(())
     }
 
     /// Ajoute un track à une playlist
     pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> {
         let user_id = self.ensure_authenticated()?;
-        debug!("Adding track {} to playlist {} for user {}", track_id, playlist_id, user_id);
+        debug!(
+            "Adding track {} to playlist {} for user {}",
+            track_id, playlist_id, user_id
+        );
 
-        let params = [
-            ("playlist_id", playlist_id),
-            ("track_ids", track_id),
-        ];
+        let params = [("playlist_id", playlist_id), ("track_ids", track_id)];
 
-        self.get::<serde_json::Value>("/playlist/addTracks", &params).await?;
+        self.get::<serde_json::Value>("/playlist/addTracks", &params)
+            .await?;
         Ok(())
     }
 }
diff --git a/pmoqobuz/src/client.rs b/pmoqobuz/src/client.rs
index 0d43a55f..51948af7 100644
--- a/pmoqobuz/src/client.rs
+++ b/pmoqobuz/src/client.rs
@@ -119,7 +119,9 @@ impl QobuzClient {
         let album = self.api.get_album(album_id).await?;
 
         // Mettre en cache
-        self.cache.put_album(album_id.to_string(), album.clone()).await;
+        self.cache
+            .put_album(album_id.to_string(), album.clone())
+            .await;
 
         Ok(album)
     }
@@ -130,9 +132,7 @@ impl QobuzClient {
 
         // Mettre les tracks en cache
         for track in &tracks {
-            self.cache
-                .put_track(track.id.clone(), track.clone())
-                .await;
+            self.cache.put_track(track.id.clone(), track.clone()).await;
         }
 
         Ok(tracks)
@@ -148,7 +148,9 @@ impl QobuzClient {
         }
 
         let track = self.api.get_track(track_id).await?;
-        self.cache.put_track(track_id.to_string(), track.clone()).await;
+        self.cache
+            .put_track(track_id.to_string(), track.clone())
+            .await;
 
         Ok(track)
     }
@@ -168,9 +170,7 @@ impl QobuzClient {
         let url = info.url.clone();
 
         // Mettre en cache
-        self.cache
-            .put_stream_url(track_id.to_string(), info)
-            .await;
+        self.cache.put_stream_url(track_id.to_string(), info).await;
 
         Ok(url)
     }
@@ -194,7 +194,10 @@ impl QobuzClient {
                 .await;
             Ok(artist)
         } else {
-            Err(QobuzError::NotFound(format!("Artist {} not found", artist_id)))
+            Err(QobuzError::NotFound(format!(
+                "Artist {} not found",
+                artist_id
+            )))
         }
     }
 
diff --git a/pmoqobuz/src/didl.rs b/pmoqobuz/src/didl.rs
index b7090684..a06f9c16 100644
--- a/pmoqobuz/src/didl.rs
+++ b/pmoqobuz/src/didl.rs
@@ -116,10 +116,7 @@ impl ToDIDL for Track {
             genre: None, // Qobuz ne fournit pas le genre au niveau track
             album_art,
             album_art_pk: None,
-            date: self
-                .album
-                .as_ref()
-                .and_then(|a| a.release_date.clone()),
+            date: self.album.as_ref().and_then(|a| a.release_date.clone()),
             original_track_number: Some(self.track_number.to_string()),
             resources: vec![resource],
             descriptions: Vec::new(),
diff --git a/pmoqobuz/src/pmoserver_ext.rs b/pmoqobuz/src/pmoserver_ext.rs
index 64d57b7b..0c8ae3a3 100644
--- a/pmoqobuz/src/pmoserver_ext.rs
+++ b/pmoqobuz/src/pmoserver_ext.rs
@@ -71,8 +71,11 @@ pub trait QobuzServerExt {
     /// - `GET /qobuz/featured/playlists` - Playlists featured
     /// - `GET /qobuz/cache/stats` - Statistiques du cache
     /// - `GET /swagger-ui` - Documentation interactive
-    async fn init_qobuz_client(&mut self, username: &str, password: &str)
-        -> Result<Arc<QobuzClient>>;
+    async fn init_qobuz_client(
+        &mut self,
+        username: &str,
+        password: &str,
+    ) -> Result<Arc<QobuzClient>>;
 
     /// Initialise le client Qobuz avec la configuration par défaut
     ///
diff --git a/pmoqobuz/src/source.rs b/pmoqobuz/src/source.rs
index aecd47df..ec45db48 100644
--- a/pmoqobuz/src/source.rs
+++ b/pmoqobuz/src/source.rs
@@ -6,11 +6,11 @@
 use crate::client::QobuzClient;
 use crate::didl::ToDIDL;
 use crate::models::Track;
-use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result};
-use pmosource::SourceCacheManager;
 use pmoaudiocache::{AudioMetadata, Cache as AudioCache};
 use pmocovers::Cache as CoverCache;
 use pmodidl::{Container, Item};
+use pmosource::SourceCacheManager;
+use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result};
 use std::sync::Arc;
 use std::time::SystemTime;
 
@@ -120,11 +120,7 @@ impl QobuzSource {
         cover_cache: Arc<CoverCache>,
         audio_cache: Arc<AudioCache>,
     ) -> Self {
-        let cache_manager = SourceCacheManager::new(
-            "qobuz".to_string(),
-            cover_cache,
-            audio_cache,
-        );
+        let cache_manager = SourceCacheManager::new("qobuz".to_string(), cover_cache, audio_cache);
 
         Self {
             inner: Arc::new(QobuzSourceInner {
@@ -148,15 +144,23 @@ impl QobuzSource {
         let track_id = format!("qobuz://track/{}", track.id);
 
         // Get streaming URL
-        let stream_url = self.inner.client.get_stream_url(&track.id).await
+        let stream_url = self
+            .inner
+            .client
+            .get_stream_url(&track.id)
+            .await
             .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))?;
 
         // 1. Cache cover via manager
         let cached_cover_pk = if let Some(ref album) = track.album {
             if let Some(ref image_url) = album.image {
                 self.inner.cache_manager.cache_cover(image_url).await.ok()
-            } else { None }
-        } else { None };
+            } else {
+                None
+            }
+        } else {
+            None
+        };
 
         // 2. Prepare rich metadata from Qobuz track
         let metadata = AudioMetadata {
@@ -165,14 +169,20 @@ impl QobuzSource {
             album: track.album.as_ref().map(|a| a.title.clone()),
             duration_secs: Some(track.duration as u64),
             year: track.album.as_ref().and_then(|a| {
-                a.release_date.as_ref().and_then(|d| d.split('-').next()?.parse().ok())
+                a.release_date
+                    .as_ref()
+                    .and_then(|d| d.split('-').next()?.parse().ok())
             }),
             track_number: Some(track.track_number),
             track_total: track.album.as_ref().and_then(|a| a.tracks_count),
             disc_number: Some(track.media_number),
             disc_total: None,
             genre: track.album.as_ref().and_then(|a| {
-                if !a.genres.is_empty() { Some(a.genres.join(", ")) } else { None }
+                if !a.genres.is_empty() {
+                    Some(a.genres.join(", "))
+                } else {
+                    None
+                }
             }),
             sample_rate: track.sample_rate,
             channels: track.channels,
@@ -180,17 +190,25 @@ impl QobuzSource {
         };
 
         // 3. Cache audio via manager
-        let cached_audio_pk = self.inner.cache_manager.cache_audio(&stream_url, Some(metadata)).await.ok();
+        let cached_audio_pk = self
+            .inner
+            .cache_manager
+            .cache_audio(&stream_url, Some(metadata))
+            .await
+            .ok();
 
         // 4. Store metadata
-        self.inner.cache_manager.update_metadata(
-            track_id.clone(),
-            pmosource::TrackMetadata {
-                original_uri: stream_url,
-                cached_audio_pk,
-                cached_cover_pk,
-            }
-        ).await;
+        self.inner
+            .cache_manager
+            .update_metadata(
+                track_id.clone(),
+                pmosource::TrackMetadata {
+                    original_uri: stream_url,
+                    cached_audio_pk,
+                    cached_cover_pk,
+                },
+            )
+            .await;
 
         Ok(track_id)
     }
@@ -375,9 +393,14 @@ impl MusicSource for QobuzSource {
         }
 
         // If not cached, extract track ID and get streaming URL from Qobuz
-        let track_id = object_id.strip_prefix("qobuz://track/").unwrap_or(object_id);
+        let track_id = object_id
+            .strip_prefix("qobuz://track/")
+            .unwrap_or(object_id);
 
-        self.inner.client.get_stream_url(track_id).await
+        self.inner
+            .client
+            .get_stream_url(track_id)
+            .await
             .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))
     }
 
@@ -534,10 +557,16 @@ impl MusicSource for QobuzSource {
 
     async fn cache_item(&self, object_id: &str) -> Result<pmosource::CacheStatus> {
         // Extract track ID
-        let track_id = object_id.strip_prefix("qobuz://track/").unwrap_or(object_id);
+        let track_id = object_id
+            .strip_prefix("qobuz://track/")
+            .unwrap_or(object_id);
 
         // Get track details from Qobuz
-        let track = self.inner.client.get_track(track_id).await
+        let track = self
+            .inner
+            .client
+            .get_track(track_id)
+            .await
             .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?;
 
         // Add track to cache (via manager)
@@ -632,11 +661,9 @@ impl MusicSource for QobuzSource {
 
                 Ok(favorites.iter().any(|track| track.id == *id))
             }
-            _ => {
-                Err(MusicSourceError::NotSupported(
-                    "Favorites only supported for albums and tracks".to_string(),
-                ))
-            }
+            _ => Err(MusicSourceError::NotSupported(
+                "Favorites only supported for albums and tracks".to_string(),
+            )),
         }
     }
 
@@ -788,7 +815,10 @@ mod tests {
         assert!(DEFAULT_IMAGE.len() > 0, "Default image should not be empty");
 
         // Check WebP magic bytes (RIFF...WEBP)
-        assert!(DEFAULT_IMAGE.len() >= 12, "Image too small to be valid WebP");
+        assert!(
+            DEFAULT_IMAGE.len() >= 12,
+            "Image too small to be valid WebP"
+        );
         assert_eq!(&DEFAULT_IMAGE[0..4], b"RIFF", "Missing RIFF header");
         assert_eq!(&DEFAULT_IMAGE[8..12], b"WEBP", "Missing WEBP signature");
     }
diff --git a/pmoserver/src/lib.rs b/pmoserver/src/lib.rs
index b68d08f5..5b58aa11 100644
--- a/pmoserver/src/lib.rs
+++ b/pmoserver/src/lib.rs
@@ -68,8 +68,11 @@
 //! # }
 //! ```
 
-pub mod server;
 pub mod logs;
+pub mod server;
 
-pub use server::{Server, ServerBuilder, ServerInfo, ApiRegistry, ApiRegistryEntry};
-pub use logs::{LogState, SseLayer, log_sse, log_dump, init_logging, LoggingOptions, log_setup_get, log_setup_post, create_logs_router, LogsApiDoc};
+pub use logs::{
+    LogState, LoggingOptions, LogsApiDoc, SseLayer, create_logs_router, init_logging, log_dump,
+    log_setup_get, log_setup_post, log_sse,
+};
+pub use server::{ApiRegistry, ApiRegistryEntry, Server, ServerBuilder, ServerInfo};
diff --git a/pmoserver/src/logs/mod.rs b/pmoserver/src/logs/mod.rs
index 1bd8abe9..840d9a4c 100644
--- a/pmoserver/src/logs/mod.rs
+++ b/pmoserver/src/logs/mod.rs
@@ -13,22 +13,22 @@ use std::{
 use axum::{
     Json,
     extract::{Query, State},
+    http::StatusCode,
     response::{
         IntoResponse,
         sse::{Event, KeepAlive, Sse},
     },
-    http::StatusCode,
 };
 use serde::{Deserialize, Serialize};
 use tokio::sync::broadcast;
+use tracing::Level;
 use tracing_subscriber::{
     Registry,
-    layer::{SubscriberExt, Filter},
-    reload,
     filter::LevelFilter,
+    layer::{Filter, SubscriberExt},
+    reload,
     util::SubscriberInitExt,
 };
-use tracing::Level;
 use utoipa::OpenApi;
 
 /// Représente une entrée de log
@@ -69,7 +69,10 @@ impl LogState {
         if let Err(e) = self.reload_handle.write().unwrap().reload(level_filter) {
             eprintln!("❌ Failed to reload log level filter: {}", e);
         } else {
-            eprintln!("✅ Log level filter reloaded successfully to: {:?}", level_filter);
+            eprintln!(
+                "✅ Log level filter reloaded successfully to: {:?}",
+                level_filter
+            );
         }
     }
 
@@ -174,7 +177,10 @@ fn is_level_allowed(log_level: &str, max_level: Level) -> bool {
         Level::ERROR => matches!(entry_level, Level::ERROR),
         Level::WARN => matches!(entry_level, Level::ERROR | Level::WARN),
         Level::INFO => matches!(entry_level, Level::ERROR | Level::WARN | Level::INFO),
-        Level::DEBUG => matches!(entry_level, Level::ERROR | Level::WARN | Level::INFO | Level::DEBUG),
+        Level::DEBUG => matches!(
+            entry_level,
+            Level::ERROR | Level::WARN | Level::INFO | Level::DEBUG
+        ),
         Level::TRACE => true, // Tous les niveaux
     }
 }
@@ -262,15 +268,15 @@ pub fn init_logging() -> LogState {
         Ok(l) => match string_to_level(&l) {
             Some(lev) => level_to_levelfilter(lev),
             None => LevelFilter::TRACE,
-        }
-        Err(_) => LevelFilter::TRACE
+        },
+        Err(_) => LevelFilter::TRACE,
     };
 
     let (filter, reload_handle) = reload::Layer::new(log_level);
 
     let buffer_capacity = match config.get_log_cache_size() {
         Ok(c) => c,
-        Err(_) => 500
+        Err(_) => 500,
     };
 
     // Créer le LogState avec le handle de rechargement
@@ -410,12 +416,12 @@ fn level_to_string(level: Level) -> String {
 
 fn level_to_levelfilter(level: Level) -> LevelFilter {
     match level {
-            Level::ERROR => LevelFilter::ERROR,
-            Level::WARN => LevelFilter::WARN,
-            Level::INFO => LevelFilter::INFO,
-            Level::DEBUG => LevelFilter::DEBUG,
-            Level::TRACE => LevelFilter::TRACE,
-        }
+        Level::ERROR => LevelFilter::ERROR,
+        Level::WARN => LevelFilter::WARN,
+        Level::INFO => LevelFilter::INFO,
+        Level::DEBUG => LevelFilter::DEBUG,
+        Level::TRACE => LevelFilter::TRACE,
+    }
 }
 
 /// Crée le router pour l'API de gestion des logs
@@ -440,4 +446,4 @@ pub fn create_logs_router(log_state: LogState) -> axum::Router {
         (name = "logs", description = "Log level configuration endpoints")
     )
 )]
-pub struct LogsApiDoc;
\ No newline at end of file
+pub struct LogsApiDoc;
diff --git a/pmoserver/src/server.rs b/pmoserver/src/server.rs
index bebcd4ff..73c3b033 100644
--- a/pmoserver/src/server.rs
+++ b/pmoserver/src/server.rs
@@ -28,8 +28,8 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::{signal, sync::RwLock, task::JoinHandle};
 use tracing::info;
-use utoipa_swagger_ui::SwaggerUi;
 use utoipa::OpenApi;
+use utoipa_swagger_ui::SwaggerUi;
 
 /// Info serveur sérialisable
 #[derive(Clone, Serialize, utoipa::ToSchema)]
@@ -435,7 +435,8 @@ impl Server {
         let swagger_path_static: &'static str = Box::leak(swagger_path.clone().into_boxed_str());
 
         let openapi_json_path = format!("/api-docs/{}.json", name);
-        let openapi_json_path_static: &'static str = Box::leak(openapi_json_path.clone().into_boxed_str());
+        let openapi_json_path_static: &'static str =
+            Box::leak(openapi_json_path.clone().into_boxed_str());
 
         // Compter le nombre d'endpoints dans l'OpenAPI spec
         let endpoint_count = openapi.paths.paths.len();
@@ -538,11 +539,35 @@ impl Server {
         }
     }
 
+    /// Retourne l'URL de base complète du serveur (schéma + hôte + port).
+    ///
+    /// La valeur configurable peut omettre le schéma ou le port ; cette méthode
+    /// s'assure donc que les clients reçoivent toujours une URL exploitable comme
+    /// `http://192.168.0.10:8080`.
+    pub fn base_url(&self) -> String {
+        let mut base = self.base_url.trim_end_matches('/').to_string();
+
+        if !base.contains("://") {
+            base = format!("http://{}", base);
+        }
+
+        let has_port = base
+            .rsplit_once(':')
+            .and_then(|(_, port)| port.parse::<u16>().ok())
+            .is_some();
+
+        if has_port {
+            base
+        } else {
+            format!("{}:{}", base, self.http_port)
+        }
+    }
+
     /// Récupère les infos du serveur
     pub fn info(&self) -> ServerInfo {
         ServerInfo {
             name: self.name.clone(),
-            base_url: self.base_url.clone(),
+            base_url: self.base_url(),
             http_port: self.http_port,
         }
     }
@@ -583,8 +608,9 @@ impl Server {
         self.add_openapi(
             crate::logs::create_logs_router(log_state.clone()),
             crate::logs::LogsApiDoc::openapi(),
-            "logs"
-        ).await;
+            "logs",
+        )
+        .await;
 
         self.log_state = Some(log_state);
     }
diff --git a/pmosource/examples/radio_paradise.rs b/pmosource/examples/radio_paradise.rs
index 54794a90..4cb02f11 100644
--- a/pmosource/examples/radio_paradise.rs
+++ b/pmosource/examples/radio_paradise.rs
@@ -16,9 +16,9 @@
 //! cargo run --example radio_paradise
 //! ```
 
-use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result};
 use pmodidl::{Container, Item, Resource};
 use pmoplaylist::{FifoPlaylist, Track};
+use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result};
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::RwLock;
@@ -353,7 +353,10 @@ async fn main() -> anyhow::Result<()> {
     println!("Source: {}", source.name());
     println!("ID: {}", source.id());
     println!("Supports FIFO: {}", source.supports_fifo());
-    println!("Default image size: {} bytes\n", source.default_image().len());
+    println!(
+        "Default image size: {} bytes\n",
+        source.default_image().len()
+    );
 
     // Add some sample tracks
     println!("Adding sample tracks...");
@@ -427,14 +430,13 @@ async fn main() -> anyhow::Result<()> {
     // Track changes
     println!("Change Tracking:");
     println!("  Update ID: {}", source.update_id().await);
-    println!(
-        "  Last Change: {:?}\n",
-        source.last_change().await.unwrap()
-    );
+    println!("  Last Change: {:?}\n", source.last_change().await.unwrap());
 
     // Simulate caching a track
     println!("Simulating cache for rp-001...");
-    source.cache_track("rp-001", "cached-abc123".to_string()).await?;
+    source
+        .cache_track("rp-001", "cached-abc123".to_string())
+        .await?;
 
     let cached_uri = source.resolve_uri("rp-001").await?;
     println!("  Cached URI: {}\n", cached_uri);
diff --git a/pmosource/src/api.rs b/pmosource/src/api.rs
index 33e86989..9b7400c3 100644
--- a/pmosource/src/api.rs
+++ b/pmosource/src/api.rs
@@ -22,7 +22,7 @@
 #[cfg(feature = "server")]
 use axum::{
     extract::Path,
-    http::{StatusCode, header},
+    http::{header, StatusCode},
     response::{IntoResponse, Response},
     routing::{delete, get},
     Json, Router,
@@ -313,21 +313,19 @@ async fn get_source_capabilities(Path(id): Path<String>) -> impl IntoResponse {
 )]
 async fn get_source_statistics(Path(id): Path<String>) -> impl IntoResponse {
     match get_source(&id).await {
-        Some(source) => {
-            match source.statistics().await {
-                Ok(stats) => {
-                    let stats_info: SourceStatisticsInfo = stats.into();
-                    (StatusCode::OK, Json(stats_info)).into_response()
-                }
-                Err(e) => (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    Json(ErrorResponse {
-                        error: format!("Failed to get statistics: {}", e),
-                    }),
-                )
-                    .into_response(),
+        Some(source) => match source.statistics().await {
+            Ok(stats) => {
+                let stats_info: SourceStatisticsInfo = stats.into();
+                (StatusCode::OK, Json(stats_info)).into_response()
             }
-        }
+            Err(e) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ErrorResponse {
+                    error: format!("Failed to get statistics: {}", e),
+                }),
+            )
+                .into_response(),
+        },
         None => (
             StatusCode::NOT_FOUND,
             Json(ErrorResponse {
@@ -357,27 +355,25 @@ async fn get_source_statistics(Path(id): Path<String>) -> impl IntoResponse {
 )]
 async fn get_source_root(Path(id): Path<String>) -> impl IntoResponse {
     match get_source(&id).await {
-        Some(source) => {
-            match source.root_container().await {
-                Ok(container) => {
-                    let root = SourceRootContainer {
-                        id: container.id,
-                        parent_id: container.parent_id,
-                        title: container.title,
-                        class: container.class,
-                        child_count: container.child_count,
-                    };
-                    (StatusCode::OK, Json(root)).into_response()
-                }
-                Err(e) => (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    Json(ErrorResponse {
-                        error: format!("Failed to get root container: {}", e),
-                    }),
-                )
-                    .into_response(),
+        Some(source) => match source.root_container().await {
+            Ok(container) => {
+                let root = SourceRootContainer {
+                    id: container.id,
+                    parent_id: container.parent_id,
+                    title: container.title,
+                    class: container.class,
+                    child_count: container.child_count,
+                };
+                (StatusCode::OK, Json(root)).into_response()
             }
-        }
+            Err(e) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ErrorResponse {
+                    error: format!("Failed to get root container: {}", e),
+                }),
+            )
+                .into_response(),
+        },
         None => (
             StatusCode::NOT_FOUND,
             Json(ErrorResponse {
diff --git a/pmosource/src/cache.rs b/pmosource/src/cache.rs
index 630783e4..291bd5ee 100644
--- a/pmosource/src/cache.rs
+++ b/pmosource/src/cache.rs
@@ -18,12 +18,12 @@
 //!       └─ collection: "qobuz"
 //! ```
 
+use crate::{CacheStatus, MusicSourceError, Result};
+use pmoaudiocache::{AudioMetadata, Cache as AudioCache};
+use pmocovers::Cache as CoverCache;
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::RwLock;
-use pmocovers::Cache as CoverCache;
-use pmoaudiocache::{Cache as AudioCache, AudioMetadata};
-use crate::{MusicSourceError, Result, CacheStatus};
 
 /// Métadonnées d'une piste en cache
 #[derive(Debug, Clone)]
@@ -76,15 +76,13 @@ impl SourceCacheManager {
     /// Retourne une erreur si les caches ne sont pas encore initialisés dans le registre
     #[cfg(feature = "server")]
     pub fn from_registry(collection_id: String) -> Result<Self> {
-        let cover_cache = pmoupnp::cache_registry::get_cover_cache()
-            .ok_or_else(|| MusicSourceError::CacheError(
-                "Cover cache not initialized in registry".to_string()
-            ))?;
+        let cover_cache = pmoupnp::cache_registry::get_cover_cache().ok_or_else(|| {
+            MusicSourceError::CacheError("Cover cache not initialized in registry".to_string())
+        })?;
 
-        let audio_cache = pmoupnp::cache_registry::get_audio_cache()
-            .ok_or_else(|| MusicSourceError::CacheError(
-                "Audio cache not initialized in registry".to_string()
-            ))?;
+        let audio_cache = pmoupnp::cache_registry::get_audio_cache().ok_or_else(|| {
+            MusicSourceError::CacheError("Audio cache not initialized in registry".to_string())
+        })?;
 
         Ok(Self {
             track_cache: RwLock::new(HashMap::new()),
@@ -132,7 +130,7 @@ impl SourceCacheManager {
                 #[cfg(not(feature = "server"))]
                 {
                     return Err(MusicSourceError::CacheError(
-                        "Server feature not enabled".to_string()
+                        "Server feature not enabled".to_string(),
                     ));
                 }
             }
@@ -190,7 +188,7 @@ impl SourceCacheManager {
         #[cfg(not(feature = "server"))]
         {
             Err(MusicSourceError::CacheError(
-                "Server feature not enabled - cannot build cover URL".to_string()
+                "Server feature not enabled - cannot build cover URL".to_string(),
             ))
         }
     }
@@ -207,11 +205,11 @@ impl SourceCacheManager {
     /// # Returns
     ///
     /// La clé primaire (pk) de la piste dans le cache
-    pub async fn cache_audio(&self, url: &str, _metadata: Option<AudioMetadata>)
-        -> Result<String> {
+    pub async fn cache_audio(&self, url: &str, _metadata: Option<AudioMetadata>) -> Result<String> {
         // Note: Les métadonnées seront extraites automatiquement par le cache audio
         // lors de la conversion FLAC
-        let pk = self.audio_cache
+        let pk = self
+            .audio_cache
             .add_from_url(url, Some(&self.collection_id))
             .await
             .map_err(|e| MusicSourceError::CacheError(e.to_string()))?;
@@ -246,7 +244,8 @@ impl SourceCacheManager {
     /// Obtenir les statistiques du cache pour cette source
     pub async fn statistics(&self) -> CacheStatistics {
         let cache = self.track_cache.read().await;
-        let cached_count = cache.values()
+        let cached_count = cache
+            .values()
             .filter(|m| m.cached_audio_pk.is_some())
             .count();
 
diff --git a/pmosource/src/lib.rs b/pmosource/src/lib.rs
index 5ba38290..6d159567 100644
--- a/pmosource/src/lib.rs
+++ b/pmosource/src/lib.rs
@@ -693,7 +693,9 @@ pub trait MusicSource: Debug + Send + Sync {
     /// ```
     async fn cache_item(&self, object_id: &str) -> Result<CacheStatus> {
         let _ = object_id;
-        Err(MusicSourceError::NotSupported("Caching not supported".to_string()))
+        Err(MusicSourceError::NotSupported(
+            "Caching not supported".to_string(),
+        ))
     }
 
     /// Add an item to favorites
@@ -715,7 +717,9 @@ pub trait MusicSource: Debug + Send + Sync {
     /// ```
     async fn add_favorite(&self, object_id: &str) -> Result<()> {
         let _ = object_id;
-        Err(MusicSourceError::NotSupported("Favorites not supported".to_string()))
+        Err(MusicSourceError::NotSupported(
+            "Favorites not supported".to_string(),
+        ))
     }
 
     /// Remove an item from favorites
@@ -731,7 +735,9 @@ pub trait MusicSource: Debug + Send + Sync {
     /// Returns `MusicSourceError::NotSupported` if favorites are not available.
     async fn remove_favorite(&self, object_id: &str) -> Result<()> {
         let _ = object_id;
-        Err(MusicSourceError::NotSupported("Favorites not supported".to_string()))
+        Err(MusicSourceError::NotSupported(
+            "Favorites not supported".to_string(),
+        ))
     }
 
     /// Check if an item is in favorites
@@ -749,7 +755,9 @@ pub trait MusicSource: Debug + Send + Sync {
     /// Returns `MusicSourceError::NotSupported` if favorites are not available.
     async fn is_favorite(&self, object_id: &str) -> Result<bool> {
         let _ = object_id;
-        Err(MusicSourceError::NotSupported("Favorites not supported".to_string()))
+        Err(MusicSourceError::NotSupported(
+            "Favorites not supported".to_string(),
+        ))
     }
 
     /// Get user playlists
@@ -773,7 +781,9 @@ pub trait MusicSource: Debug + Send + Sync {
     /// }
     /// ```
     async fn get_user_playlists(&self) -> Result<Vec<Container>> {
-        Err(MusicSourceError::NotSupported("Playlists not supported".to_string()))
+        Err(MusicSourceError::NotSupported(
+            "Playlists not supported".to_string(),
+        ))
     }
 
     /// Add an item to a playlist
@@ -788,7 +798,9 @@ pub trait MusicSource: Debug + Send + Sync {
     /// Returns `MusicSourceError::NotSupported` if playlists are not available.
     async fn add_to_playlist(&self, playlist_id: &str, item_id: &str) -> Result<()> {
         let _ = (playlist_id, item_id);
-        Err(MusicSourceError::NotSupported("Playlists not supported".to_string()))
+        Err(MusicSourceError::NotSupported(
+            "Playlists not supported".to_string(),
+        ))
     }
 
     /// Get total item count for a container
@@ -907,7 +919,7 @@ pub use pmodidl;
 pub use pmoplaylist;
 
 // Re-export cache types
-pub use cache::{TrackMetadata, SourceCacheManager, CacheStatistics};
+pub use cache::{CacheStatistics, SourceCacheManager, TrackMetadata};
 
 // Server extension modules (feature-gated)
 #[cfg(feature = "server")]
diff --git a/pmosource/src/pmoserver_impl.rs b/pmosource/src/pmoserver_impl.rs
index 106c7d50..c59a5a9e 100644
--- a/pmosource/src/pmoserver_impl.rs
+++ b/pmosource/src/pmoserver_impl.rs
@@ -30,7 +30,10 @@
 //! ```
 
 #[cfg(feature = "server")]
-use crate::api::{register_source, unregister_source, list_all_sources, get_source, create_sources_router, SourcesApiDoc};
+use crate::api::{
+    create_sources_router, get_source, list_all_sources, register_source, unregister_source,
+    SourcesApiDoc,
+};
 #[cfg(feature = "server")]
 use crate::pmoserver_ext::MusicSourceExt;
 #[cfg(feature = "server")]
diff --git a/pmoupnp/src/actions/action_handler.rs b/pmoupnp/src/actions/action_handler.rs
index 7abd2360..7ef36045 100644
--- a/pmoupnp/src/actions/action_handler.rs
+++ b/pmoupnp/src/actions/action_handler.rs
@@ -97,7 +97,8 @@ pub type ActionData = HashMap<String, Box<dyn Reflect>>;
 /// - Le handler retourne les données modifiées (ActionData unifié pour entrée/sortie)
 /// - Rarement utilisé directement (la macro `action_handler!` s'en charge)
 /// - Nécessaire pour la compatibilité avec les trait objects
-pub type ActionFuture = Pin<Box<dyn Future<Output = Result<ActionData, crate::actions::ActionError>> + Send>>;
+pub type ActionFuture =
+    Pin<Box<dyn Future<Output = Result<ActionData, crate::actions::ActionError>> + Send>>;
 
 /// Handler d'action UPnP asynchrone.
 ///
diff --git a/pmoupnp/src/actions/action_instance.rs b/pmoupnp/src/actions/action_instance.rs
index 9b92e858..2abbcff3 100644
--- a/pmoupnp/src/actions/action_instance.rs
+++ b/pmoupnp/src/actions/action_instance.rs
@@ -6,20 +6,9 @@ use std::{
 use bevy_reflect::Reflect;
 use xmltree::{Element, XMLNode};
 
-use crate::{
-    UpnpInstance,
-    UpnpObject,
-    UpnpObjectType,
-    UpnpTyped,
-    UpnpTypedInstance,
-};
-use crate::actions::{
-    Action,
-    ActionData,
-    ActionInstance,
-    ArgInstanceSet,
-};
+use crate::actions::{Action, ActionData, ActionInstance, ArgInstanceSet};
 use crate::variable_types::StateValue;
+use crate::{UpnpInstance, UpnpObject, UpnpObjectType, UpnpTyped, UpnpTypedInstance};
 
 impl UpnpObject for ActionInstance {
     fn to_xml_element(&self) -> Element {
@@ -27,7 +16,9 @@ impl UpnpObject for ActionInstance {
 
         // <name>
         let mut name_elem = Element::new("name");
-        name_elem.children.push(XMLNode::Text(self.get_name().clone()));
+        name_elem
+            .children
+            .push(XMLNode::Text(self.get_name().clone()));
         elem.children.push(XMLNode::Element(name_elem));
 
         // Utiliser le set d'instances d'arguments
@@ -35,7 +26,7 @@ impl UpnpObject for ActionInstance {
         elem.children.push(XMLNode::Element(args_container));
 
         elem
-    }  
+    }
 }
 
 impl UpnpTyped for ActionInstance {
@@ -45,35 +36,31 @@ impl UpnpTyped for ActionInstance {
 }
 
 impl UpnpInstance for ActionInstance {
-
     type Model = Action;
 
     fn new(action: &Action) -> Self {
         // Créer les instances d'arguments
         let mut arguments = ArgInstanceSet::new();
-        
+
         for arg_model in action.arguments().all() {
             let arg_instance = Arc::new(crate::actions::ArgumentInstance::new(&*arg_model));
             if let Err(e) = arguments.insert(arg_instance) {
                 tracing::error!("Failed to insert argument instance: {:?}", e);
             }
         }
-        
+
         Self {
             object: UpnpObjectType {
                 name: action.get_name().clone(),
                 object_type: "ActionInstance".to_string(),
             },
             model: action.clone(),
-            arguments,  // ⬅️ Set d'instances, pas le modèle !
+            arguments, // ⬅️ Set d'instances, pas le modèle !
         }
     }
-
 }
 
-
 impl UpnpTypedInstance for ActionInstance {
-
     fn get_model(&self) -> &Self::Model {
         &self.model
     }
@@ -131,7 +118,7 @@ impl ActionInstance {
     /// }
     /// ```
     pub fn arguments_set(&self) -> &ArgInstanceSet {
-        &self.arguments  // ⬅️ Retourne les INSTANCES, pas les modèles !
+        &self.arguments // ⬅️ Retourne les INSTANCES, pas les modèles !
     }
 
     /// Construit un [`ActionData`] initial à partir des variables d'état liées.
@@ -186,10 +173,9 @@ impl ActionInstance {
             if arg_inst.get_model().is_in() && updated_keys.contains(arg_inst.get_name()) {
                 if let Some(var_inst) = arg_inst.get_variable_instance() {
                     if let Some(reflect_value) = action_data.get(arg_inst.get_name()) {
-                        let cloned = reflect_value
-                            .as_ref()
-                            .reflect_clone()
-                            .map_err(|e| crate::actions::ActionError::ArgumentError(e.to_string()))?;
+                        let cloned = reflect_value.as_ref().reflect_clone().map_err(|e| {
+                            crate::actions::ActionError::ArgumentError(e.to_string())
+                        })?;
                         var_inst
                             .set_reflect_value(cloned)
                             .await
@@ -269,22 +255,22 @@ impl ActionInstance {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::actions::Action;
     use crate::UpnpInstance;
+    use crate::actions::Action;
 
     #[test]
     fn test_action_instance_creation() {
         let action = Action::new("Play".to_string());
         let instance = ActionInstance::new(&action);
-        
+
         assert_eq!(instance.get_name(), "Play");
     }
-    
+
     #[test]
     fn test_action_instance_has_argument_instances() {
         let action = Action::new("Play".to_string());
         let instance = ActionInstance::new(&action);
-        
+
         // Vérifier que arguments_set() retourne bien des instances
         assert!(instance.arguments_set().all().iter().all(|arg| {
             // Chaque argument doit être une ArgumentInstance
diff --git a/pmoupnp/src/actions/action_instance_set.rs b/pmoupnp/src/actions/action_instance_set.rs
index ec2725ca..2090ca81 100644
--- a/pmoupnp/src/actions/action_instance_set.rs
+++ b/pmoupnp/src/actions/action_instance_set.rs
@@ -1,9 +1,6 @@
-use crate::{
-    UpnpObject,
-    actions::{ActionInstanceSet},
-};
+use crate::{UpnpObject, actions::ActionInstanceSet};
 
-use xmltree::{Element,XMLNode};
+use xmltree::{Element, XMLNode};
 
 impl UpnpObject for ActionInstanceSet {
     // Méthode pour convertir en XML (à implémenter avec une librairie XML)
@@ -18,4 +15,3 @@ impl UpnpObject for ActionInstanceSet {
         elem
     }
 }
-
diff --git a/pmoupnp/src/actions/action_methods.rs b/pmoupnp/src/actions/action_methods.rs
index 571b5259..ff60b6f1 100644
--- a/pmoupnp/src/actions/action_methods.rs
+++ b/pmoupnp/src/actions/action_methods.rs
@@ -3,21 +3,8 @@ use std::sync::Arc;
 use tracing::{info, trace};
 use xmltree::{Element, XMLNode};
 
-use crate::{
-    action_handler,
-    UpnpModel,
-    UpnpObject,
-    UpnpObjectSetError,
-    UpnpObjectType,
-    UpnpTyped,
-};
-use crate::actions::{
-    Action,
-    ActionHandler,
-    ActionInstance,
-    Argument,
-    ArgumentSet,
-};
+use crate::actions::{Action, ActionHandler, ActionInstance, Argument, ArgumentSet};
+use crate::{UpnpModel, UpnpObject, UpnpObjectSetError, UpnpObjectType, UpnpTyped, action_handler};
 
 impl UpnpObject for Action {
     fn to_xml_element(&self) -> Element {
@@ -108,7 +95,7 @@ impl Action {
             },
             arguments: ArgumentSet::new(),
             handle: Self::default_handler(),
-            stateful: true,  // Par défaut, les actions sont stateful
+            stateful: true, // Par défaut, les actions sont stateful
         }
     }
 
@@ -188,13 +175,12 @@ impl Action {
         self.stateful = stateful;
         self
     }
-    
+
     pub fn set_stateless(&mut self, stateless: bool) -> &mut Self {
         self.stateful = !stateless;
         self
     }
 
-
     /// Retourne `true` si l'action est stateful.
     ///
     /// # Returns
diff --git a/pmoupnp/src/actions/action_set_methods.rs b/pmoupnp/src/actions/action_set_methods.rs
index 4574a088..d7e3a844 100644
--- a/pmoupnp/src/actions/action_set_methods.rs
+++ b/pmoupnp/src/actions/action_set_methods.rs
@@ -4,7 +4,7 @@ use crate::actions::{ActionInstanceSet, ActionSet};
 use crate::{UpnpModel, UpnpObject};
 
 impl UpnpObject for ActionSet {
-         fn to_xml_element(&self) -> Element {
+    fn to_xml_element(&self) -> Element {
         let mut elem = Element::new("actionList");
 
         for action in self.all() {
@@ -14,10 +14,8 @@ impl UpnpObject for ActionSet {
 
         elem
     }
-
 }
 
-
 impl UpnpModel for ActionSet {
     type Instance = ActionInstanceSet;
-}
\ No newline at end of file
+}
diff --git a/pmoupnp/src/actions/arg_inst_set_methods.rs b/pmoupnp/src/actions/arg_inst_set_methods.rs
index 92bc0f84..d2b07966 100644
--- a/pmoupnp/src/actions/arg_inst_set_methods.rs
+++ b/pmoupnp/src/actions/arg_inst_set_methods.rs
@@ -3,14 +3,17 @@ use std::collections::HashMap;
 use std::sync::RwLock;
 use xmltree::{Element, XMLNode};
 
-use crate::{actions::{ArgInstanceSet, ArgumentSet}, UpnpObject};
+use crate::{
+    UpnpObject,
+    actions::{ArgInstanceSet, ArgumentSet},
+};
 
 use crate::UpnpInstance;
 
 impl UpnpObject for ArgInstanceSet {
     fn to_xml_element(&self) -> Element {
         let mut elem = Element::new("serviceStateTable");
-        
+
         for state_var in self.all() {
             let state_var_elem = state_var.to_xml_element(); // retourne un <stateVariable> complet
             elem.children.push(XMLNode::Element(state_var_elem));
@@ -24,8 +27,8 @@ impl UpnpInstance for ArgInstanceSet {
     type Model = ArgumentSet;
 
     fn new(_: &ArgumentSet) -> Self {
-        Self { objects: RwLock::new(HashMap::new()) }
+        Self {
+            objects: RwLock::new(HashMap::new()),
+        }
     }
 }
-
-
diff --git a/pmoupnp/src/actions/arg_instance_methods.rs b/pmoupnp/src/actions/arg_instance_methods.rs
index 0316b6a6..390d9225 100644
--- a/pmoupnp/src/actions/arg_instance_methods.rs
+++ b/pmoupnp/src/actions/arg_instance_methods.rs
@@ -1,9 +1,15 @@
-use std::{collections::HashMap, sync::{Arc, RwLock}};
+use std::{
+    collections::HashMap,
+    sync::{Arc, RwLock},
+};
 
 use xmltree::Element;
 
-use crate::{actions::{ActionInstanceSet, ActionSet, Argument, ArgumentInstance}, state_variables::StateVarInstance, UpnpInstance, UpnpObject, UpnpObjectType, UpnpTyped, UpnpTypedInstance};
-
+use crate::{
+    UpnpInstance, UpnpObject, UpnpObjectType, UpnpTyped, UpnpTypedInstance,
+    actions::{ActionInstanceSet, ActionSet, Argument, ArgumentInstance},
+    state_variables::StateVarInstance,
+};
 
 impl UpnpObject for ArgumentInstance {
     fn to_xml_element(&self) -> Element {
@@ -46,7 +52,6 @@ impl UpnpTypedInstance for ArgumentInstance {
     }
 }
 
-
 /// Implémentation de [`UpnpInstance`] pour [`ArgumentInstance`].
 ///
 /// Cette implémentation fournit le constructeur standard qui crée une instance
@@ -80,14 +85,14 @@ impl UpnpTypedInstance for ArgumentInstance {
 /// use pmoupnp::UpnpInstance;
 ///
 /// let arg_model = Argument::new_in("InstanceID".to_string(), instance_id_var);
-/// 
+///
 /// // Création de l'instance - Phase 1
 /// let arg_instance = ArgumentInstance::new(&arg_model);
-/// 
+///
 /// // À ce stade, l'instance existe mais n'est pas encore liée
 /// assert_eq!(arg_instance.get_name(), "InstanceID");
 /// assert!(arg_instance.get_variable_instance().is_none());
-/// 
+///
 /// // La liaison se fera plus tard via bind_variable()
 /// ```
 impl UpnpInstance for ArgumentInstance {
@@ -119,14 +124,14 @@ impl UpnpInstance for ArgumentInstance {
     ///
     /// ```ignore
     /// use pmoupnp::UpnpInstance;
-    /// 
+    ///
     /// // Création depuis un modèle
     /// let instance = ArgumentInstance::new(&arg_model);
-    /// 
+    ///
     /// // L'instance hérite des propriétés du modèle
     /// assert_eq!(instance.get_name(), arg_model.get_name());
     /// assert_eq!(instance.is_in(), arg_model.is_in());
-    /// 
+    ///
     /// // Mais n'a pas encore de valeur runtime
     /// assert!(instance.get_variable_instance().is_none());
     /// ```
@@ -176,13 +181,13 @@ impl ArgumentInstance {
     ///
     /// ```ignore
     /// use std::sync::Arc;
-    /// 
+    ///
     /// let arg_instance = ArgumentInstance::new(&arg_model);
     /// let var_instance = Arc::new(StateVarInstance::new(&state_var));
-    /// 
+    ///
     /// // Établir la liaison
     /// arg_instance.bind_variable(var_instance.clone());
-    /// 
+    ///
     /// // Vérifier que la liaison est établie
     /// assert!(arg_instance.get_variable_instance().is_some());
     /// ```
@@ -244,13 +249,12 @@ impl ArgumentInstance {
     }
 }
 
-
 impl UpnpInstance for ActionInstanceSet {
     type Model = ActionSet;
-    
+
     fn new(_: &ActionSet) -> Self {
-        Self { 
-            objects: RwLock::new(HashMap::new()) 
+        Self {
+            objects: RwLock::new(HashMap::new()),
         }
     }
-}
\ No newline at end of file
+}
diff --git a/pmoupnp/src/actions/arg_set_methods.rs b/pmoupnp/src/actions/arg_set_methods.rs
index a8f7cae5..74a60798 100644
--- a/pmoupnp/src/actions/arg_set_methods.rs
+++ b/pmoupnp/src/actions/arg_set_methods.rs
@@ -1,9 +1,6 @@
-use crate::actions::ArgInstanceSet;
 use crate::UpnpModel;
-use crate::{
-    UpnpObject,
-    actions::{ArgumentSet},
-};
+use crate::actions::ArgInstanceSet;
+use crate::{UpnpObject, actions::ArgumentSet};
 use xmltree::Element;
 
 impl UpnpObject for ArgumentSet {
diff --git a/pmoupnp/src/actions/argument_methods.rs b/pmoupnp/src/actions/argument_methods.rs
index 84e6e69a..c8263f5a 100644
--- a/pmoupnp/src/actions/argument_methods.rs
+++ b/pmoupnp/src/actions/argument_methods.rs
@@ -3,7 +3,9 @@ use std::sync::Arc;
 use xmltree::{Element, XMLNode};
 
 use crate::{
-    actions::{Argument, ArgumentInstance}, state_variables::StateVariable, UpnpModel, UpnpObject, UpnpObjectType, UpnpTyped
+    UpnpModel, UpnpObject, UpnpObjectType, UpnpTyped,
+    actions::{Argument, ArgumentInstance},
+    state_variables::StateVariable,
 };
 
 impl UpnpTyped for Argument {
@@ -46,8 +48,6 @@ impl UpnpModel for Argument {
     type Instance = ArgumentInstance;
 }
 
-
-
 impl Argument {
     fn new(name: String, state_variable: Arc<StateVariable>) -> Self {
         Self {
diff --git a/pmoupnp/src/actions/errors.rs b/pmoupnp/src/actions/errors.rs
index 409d5045..f332e772 100644
--- a/pmoupnp/src/actions/errors.rs
+++ b/pmoupnp/src/actions/errors.rs
@@ -4,10 +4,10 @@ use thiserror::Error;
 pub enum ActionError {
     #[error("Action error: {0}")]
     GeneralError(String),
-    
+
     #[error("Argument error: {0}")]
     ArgumentError(String),
-    
+
     #[error("Set operation error: {0}")]
     SetError(String),
 }
@@ -22,10 +22,10 @@ impl From<std::io::Error> for ActionError {
 pub enum ArgumentError {
     #[error("Argument error: {0}")]
     GeneralError(String),
-    
+
     #[error("Argument error: {0}")]
     ArgumentError(String),
-    
+
     #[error("Set operation error: {0}")]
     SetError(String),
 }
@@ -34,4 +34,4 @@ impl From<std::io::Error> for ArgumentError {
     fn from(err: std::io::Error) -> Self {
         ArgumentError::GeneralError(format!("IO error: {}", err))
     }
-}
\ No newline at end of file
+}
diff --git a/pmoupnp/src/actions/handler_helpers.rs b/pmoupnp/src/actions/handler_helpers.rs
index 7cadadcc..a42e9ed0 100644
--- a/pmoupnp/src/actions/handler_helpers.rs
+++ b/pmoupnp/src/actions/handler_helpers.rs
@@ -33,8 +33,8 @@
 //! });
 //! ```
 
-use bevy_reflect::Reflect;
 use crate::actions::{ActionData, ActionError};
+use bevy_reflect::Reflect;
 
 /// Extrait une valeur typée depuis ActionData.
 ///
@@ -73,17 +73,13 @@ use crate::actions::{ActionData, ActionError};
 /// let volume: u32 = get_value(&data, "Volume").unwrap();
 /// assert_eq!(volume, 50);
 /// ```
-pub fn get_value<T: Reflect + Clone>(
-    data: &ActionData,
-    key: &str
-) -> Result<T, ActionError> {
+pub fn get_value<T: Reflect + Clone>(data: &ActionData, key: &str) -> Result<T, ActionError> {
     data.get(key)
         .and_then(|boxed| boxed.as_any().downcast_ref::<T>())
         .cloned()
-        .ok_or_else(|| ActionError::ArgumentError(format!(
-            "Argument '{}' not found or type mismatch",
-            key
-        )))
+        .ok_or_else(|| {
+            ActionError::ArgumentError(format!("Argument '{}' not found or type mismatch", key))
+        })
 }
 
 /// Insère une valeur dans ActionData.
@@ -115,11 +111,7 @@ pub fn get_value<T: Reflect + Clone>(
 /// let volume: u32 = get_value(&data, "Volume").unwrap();
 /// assert_eq!(volume, 75);
 /// ```
-pub fn set_value<T: Reflect + 'static>(
-    data: &mut ActionData,
-    key: impl Into<String>,
-    value: T
-) {
+pub fn set_value<T: Reflect + 'static>(data: &mut ActionData, key: impl Into<String>, value: T) {
     data.insert(key.into(), Box::new(value));
 }
 
diff --git a/pmoupnp/src/actions/macros.rs b/pmoupnp/src/actions/macros.rs
index 8ed93e84..f88cb0cf 100644
--- a/pmoupnp/src/actions/macros.rs
+++ b/pmoupnp/src/actions/macros.rs
@@ -189,22 +189,22 @@ macro_rules! define_action {
                 std::sync::Arc::new(ac)
             });
     };
-    
+
     // Helper interne pour créer un argument d'entrée
     (@arg in $name:literal, $var:expr) => {
         std::sync::Arc::new(
             $crate::actions::Argument::new_in(
-                $name.to_string(), 
+                $name.to_string(),
                 std::sync::Arc::clone(&$var)
             )
         )
     };
-    
+
     // Helper interne pour créer un argument de sortie
     (@arg out $name:literal, $var:expr) => {
         std::sync::Arc::new(
             $crate::actions::Argument::new_out(
-                $name.to_string(), 
+                $name.to_string(),
                 std::sync::Arc::clone(&$var)
             )
         )
diff --git a/pmoupnp/src/actions/mod.rs b/pmoupnp/src/actions/mod.rs
index 2d63aab9..a6ba0e16 100644
--- a/pmoupnp/src/actions/mod.rs
+++ b/pmoupnp/src/actions/mod.rs
@@ -1,9 +1,9 @@
 mod errors;
 
+mod action_handler;
 mod action_instance;
 mod action_instance_set;
 mod action_methods;
-mod action_handler;
 mod action_set_methods;
 mod arg_inst_set_methods;
 mod arg_instance_methods;
@@ -19,8 +19,8 @@ use crate::{
 };
 use std::sync::{Arc, RwLock};
 
-pub use errors::ActionError;
 pub use action_handler::{ActionData, ActionFuture, ActionHandler};
+pub use errors::ActionError;
 pub use handler_helpers::{get_value, reflect_to_string, set_value};
 
 /// Action UPnP.
diff --git a/pmoupnp/src/cache_registry.rs b/pmoupnp/src/cache_registry.rs
index 44dbc163..bd265296 100644
--- a/pmoupnp/src/cache_registry.rs
+++ b/pmoupnp/src/cache_registry.rs
@@ -7,12 +7,12 @@
 //! Les caches supportent les collections, permettant à chaque source
 //! d'avoir sa propre collection dans le cache partagé.
 
-use std::sync::Arc;
 use once_cell::sync::Lazy;
-use pmocache::FileCache;
-use std::sync::RwLock;
-use pmocovers::Cache as CoverCache;
 use pmoaudiocache::Cache as AudioCache;
+use pmocache::FileCache;
+use pmocovers::Cache as CoverCache;
+use std::sync::Arc;
+use std::sync::RwLock;
 
 /// Registre global des caches
 ///
@@ -80,16 +80,16 @@ impl CacheRegistry {
     ///
     /// URL complète (ex: "http://localhost:8080/covers/images/abc123/300")
     pub fn build_cover_url(&self, pk: &str, size: Option<usize>) -> anyhow::Result<String> {
-        let base_url = self.base_url
+        let base_url = self
+            .base_url
             .as_ref()
             .ok_or_else(|| anyhow::anyhow!("Base URL not set in CacheRegistry"))?;
-        let cache = get_cover_cache()
-        .ok_or_else(|| anyhow::anyhow!("No registred cover cache"))?;
-        let param=  match size {
+        let cache = get_cover_cache().ok_or_else(|| anyhow::anyhow!("No registred cover cache"))?;
+        let param = match size {
             Some(size_) => Some(size_.to_string()),
-            None => None  
+            None => None,
         };
-        let route = cache.route_for(pk, param.as_deref());           
+        let route = cache.route_for(pk, param.as_deref());
         Ok(format!("{}{}", base_url, route))
     }
 
@@ -104,12 +104,12 @@ impl CacheRegistry {
     ///
     /// URL complète (ex: "http://localhost:8080/audio/tracks/abc123/orig")
     pub fn build_audio_url(&self, pk: &str, param: Option<&str>) -> anyhow::Result<String> {
-        let base_url = self.base_url
+        let base_url = self
+            .base_url
             .as_ref()
             .ok_or_else(|| anyhow::anyhow!("Base URL not set in CacheRegistry"))?;
-        let cache = get_audio_cache()
-        .ok_or_else(|| anyhow::anyhow!("No registred audio cache"))?;
-        let route = cache.route_for(pk, param);           
+        let cache = get_audio_cache().ok_or_else(|| anyhow::anyhow!("No registred audio cache"))?;
+        let route = cache.route_for(pk, param);
         Ok(format!("{}{}", base_url, route))
     }
 }
@@ -124,9 +124,8 @@ impl Default for CacheRegistry {
 ///
 /// Utilise Lazy pour une initialisation paresseuse et RwLock pour le partage entre threads.
 /// Permet aux handlers et aux sources d'accéder aux caches depuis n'importe où.
-pub(crate) static CACHE_REGISTRY: Lazy<RwLock<CacheRegistry>> = Lazy::new(|| {
-    RwLock::new(CacheRegistry::new())
-});
+pub(crate) static CACHE_REGISTRY: Lazy<RwLock<CacheRegistry>> =
+    Lazy::new(|| RwLock::new(CacheRegistry::new()));
 
 /// Accès global au cache de couvertures
 ///
diff --git a/pmoupnp/src/devices/device.rs b/pmoupnp/src/devices/device.rs
index 268f6e47..d947c9ea 100644
--- a/pmoupnp/src/devices/device.rs
+++ b/pmoupnp/src/devices/device.rs
@@ -1,12 +1,9 @@
 //! Définition du modèle Device UPnP.
 
-use std::sync::{Arc, RwLock};
 use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 
-use crate::{
-    UpnpTyped, UpnpObjectType,
-    services::Service,
-};
+use crate::{UpnpObjectType, UpnpTyped, services::Service};
 
 use super::errors::DeviceError;
 
@@ -129,7 +126,10 @@ impl Device {
     ///
     /// Format: `urn:schemas-upnp-org:device:{type}:{version}`
     pub fn device_type(&self) -> String {
-        format!("urn:schemas-upnp-org:device:{}:{}", self.device_type, self.version)
+        format!(
+            "urn:schemas-upnp-org:device:{}:{}",
+            self.device_type, self.version
+        )
     }
 
     pub fn device_category(&self) -> &String {
diff --git a/pmoupnp/src/devices/device_instance.rs b/pmoupnp/src/devices/device_instance.rs
index cc7d59b3..1e906c74 100644
--- a/pmoupnp/src/devices/device_instance.rs
+++ b/pmoupnp/src/devices/device_instance.rs
@@ -1,20 +1,20 @@
 //! Implémentation de DeviceInstance.
 
-use std::{
-    collections::HashMap,
-    sync::{Arc, RwLock},
-};
 use axum::{
     http::StatusCode,
     response::{IntoResponse, Response},
 };
+use std::{
+    collections::HashMap,
+    sync::{Arc, RwLock},
+};
 use tracing::info;
-use xmltree::{Element, XMLNode, EmitterConfig};
+use xmltree::{Element, EmitterConfig, XMLNode};
 
 use crate::{
+    UpnpInstance, UpnpObject, UpnpObjectType, UpnpTyped, UpnpTypedInstance,
     devices::{Device, errors::DeviceError},
     services::ServiceInstance,
-    UpnpObject, UpnpInstance, UpnpTyped, UpnpTypedInstance, UpnpObjectType,
 };
 
 /// Instance d'un device UPnP.
@@ -79,7 +79,9 @@ impl UpnpInstance for DeviceInstance {
         // Obtenir ou créer un UDN persistant via la configuration
         let device_name = model.get_name();
         let device_type = model.device_category();
-        let udn = if let Ok(config_udn) = pmoconfig::get_config().get_device_udn(&device_type, device_name) {
+        let udn = if let Ok(config_udn) =
+            pmoconfig::get_config().get_device_udn(&device_type, device_name)
+        {
             config_udn
         } else {
             // Fallback : générer un UDN
@@ -88,6 +90,7 @@ impl UpnpInstance for DeviceInstance {
         };
 
         // Obtenir l'IP locale et le port depuis la configuration
+        // TODO: c'est amusant cet instanciation sauvage de base_url
         let local_ip = pmoutils::guess_local_ip();
         let port = pmoconfig::get_config().get_http_port();
         let server_base_url = format!("http://{}:{}", local_ip, port);
@@ -118,22 +121,30 @@ impl UpnpObject for DeviceInstance {
 
         // deviceType
         let mut device_type = Element::new("deviceType");
-        device_type.children.push(XMLNode::Text(self.model.device_type()));
+        device_type
+            .children
+            .push(XMLNode::Text(self.model.device_type()));
         elem.children.push(XMLNode::Element(device_type));
 
         // friendlyName
         let mut friendly_name = Element::new("friendlyName");
-        friendly_name.children.push(XMLNode::Text(self.model.friendly_name().to_string()));
+        friendly_name
+            .children
+            .push(XMLNode::Text(self.model.friendly_name().to_string()));
         elem.children.push(XMLNode::Element(friendly_name));
 
         // manufacturer
         let mut manufacturer = Element::new("manufacturer");
-        manufacturer.children.push(XMLNode::Text(self.model.manufacturer().to_string()));
+        manufacturer
+            .children
+            .push(XMLNode::Text(self.model.manufacturer().to_string()));
         elem.children.push(XMLNode::Element(manufacturer));
 
         // modelName
         let mut model_name = Element::new("modelName");
-        model_name.children.push(XMLNode::Text(self.model.model_name().to_string()));
+        model_name
+            .children
+            .push(XMLNode::Text(self.model.model_name().to_string()));
         elem.children.push(XMLNode::Element(model_name));
 
         // UDN
@@ -146,7 +157,9 @@ impl UpnpObject for DeviceInstance {
         if !services.is_empty() {
             let mut service_list = Element::new("serviceList");
             for service in services.values() {
-                service_list.children.push(XMLNode::Element(service.to_xml_element()));
+                service_list
+                    .children
+                    .push(XMLNode::Element(service.to_xml_element()));
             }
             elem.children.push(XMLNode::Element(service_list));
         }
@@ -156,7 +169,9 @@ impl UpnpObject for DeviceInstance {
         if !devices.is_empty() {
             let mut device_list = Element::new("deviceList");
             for device in devices.values() {
-                device_list.children.push(XMLNode::Element(device.to_xml_element()));
+                device_list
+                    .children
+                    .push(XMLNode::Element(device.to_xml_element()));
             }
             elem.children.push(XMLNode::Element(device_list));
         }
@@ -164,7 +179,9 @@ impl UpnpObject for DeviceInstance {
         // presentationURL
         if let Some(url) = self.model.presentation_url() {
             let mut presentation_url = Element::new("presentationURL");
-            presentation_url.children.push(XMLNode::Text(url.to_string()));
+            presentation_url
+                .children
+                .push(XMLNode::Text(url.to_string()));
             elem.children.push(XMLNode::Element(presentation_url));
         }
 
@@ -251,7 +268,10 @@ impl DeviceInstance {
     }
 
     /// Enregistre toutes les URLs du device et de ses services dans le serveur.
-    pub fn register_urls<'a>(&'a self, server: &'a mut pmoserver::Server) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), DeviceError>> + 'a>> {
+    pub fn register_urls<'a>(
+        &'a self,
+        server: &'a mut pmoserver::Server,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), DeviceError>> + 'a>> {
         Box::pin(async move {
             info!(
                 "✅ Device description for {} available at: {}{}",
@@ -262,14 +282,18 @@ impl DeviceInstance {
 
             // Handler pour la description du device
             let instance_desc = self.clone();
-            server.add_handler(&self.description_route(), move || {
-                let instance = instance_desc.clone();
-                async move { instance.description_handler().await }
-            }).await;
+            server
+                .add_handler(&self.description_route(), move || {
+                    let instance = instance_desc.clone();
+                    async move { instance.description_handler().await }
+                })
+                .await;
 
             // Enregistrer les services
             for service in self.services() {
-                service.register_urls(server).await
+                service
+                    .register_urls(server)
+                    .await
                     .map_err(|e| DeviceError::UrlRegistrationError(e.to_string()))?;
             }
 
@@ -330,9 +354,13 @@ impl DeviceInstance {
 
         (
             StatusCode::OK,
-            [(axum::http::header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],
+            [(
+                axum::http::header::CONTENT_TYPE,
+                "text/xml; charset=\"utf-8\"",
+            )],
             xml,
-        ).into_response()
+        )
+            .into_response()
     }
 
     /// Crée un SsdpDevice configuré pour ce device UPnP.
diff --git a/pmoupnp/src/devices/device_methods.rs b/pmoupnp/src/devices/device_methods.rs
index 6590d788..72f4cabc 100644
--- a/pmoupnp/src/devices/device_methods.rs
+++ b/pmoupnp/src/devices/device_methods.rs
@@ -4,8 +4,8 @@ use std::sync::Arc;
 use xmltree::{Element, XMLNode};
 
 use crate::{
+    UpnpInstance, UpnpModel, UpnpObject,
     devices::{Device, DeviceInstance},
-    UpnpObject, UpnpModel, UpnpInstance,
 };
 
 impl UpnpObject for Device {
@@ -19,37 +19,49 @@ impl UpnpObject for Device {
 
         // friendlyName
         let mut friendly_name = Element::new("friendlyName");
-        friendly_name.children.push(XMLNode::Text(self.friendly_name().to_string()));
+        friendly_name
+            .children
+            .push(XMLNode::Text(self.friendly_name().to_string()));
         elem.children.push(XMLNode::Element(friendly_name));
 
         // manufacturer
         let mut manufacturer = Element::new("manufacturer");
-        manufacturer.children.push(XMLNode::Text(self.manufacturer().to_string()));
+        manufacturer
+            .children
+            .push(XMLNode::Text(self.manufacturer().to_string()));
         elem.children.push(XMLNode::Element(manufacturer));
 
         // manufacturerURL (optionnel)
         if let Some(url) = self.manufacturer_url() {
             let mut manufacturer_url = Element::new("manufacturerURL");
-            manufacturer_url.children.push(XMLNode::Text(url.to_string()));
+            manufacturer_url
+                .children
+                .push(XMLNode::Text(url.to_string()));
             elem.children.push(XMLNode::Element(manufacturer_url));
         }
 
         // modelDescription (optionnel)
         if let Some(desc) = self.model_description() {
             let mut model_description = Element::new("modelDescription");
-            model_description.children.push(XMLNode::Text(desc.to_string()));
+            model_description
+                .children
+                .push(XMLNode::Text(desc.to_string()));
             elem.children.push(XMLNode::Element(model_description));
         }
 
         // modelName
         let mut model_name = Element::new("modelName");
-        model_name.children.push(XMLNode::Text(self.model_name().to_string()));
+        model_name
+            .children
+            .push(XMLNode::Text(self.model_name().to_string()));
         elem.children.push(XMLNode::Element(model_name));
 
         // modelNumber (optionnel)
         if let Some(number) = self.model_number() {
             let mut model_number = Element::new("modelNumber");
-            model_number.children.push(XMLNode::Text(number.to_string()));
+            model_number
+                .children
+                .push(XMLNode::Text(number.to_string()));
             elem.children.push(XMLNode::Element(model_number));
         }
 
@@ -63,7 +75,9 @@ impl UpnpObject for Device {
         // serialNumber (optionnel)
         if let Some(serial) = self.serial_number() {
             let mut serial_number = Element::new("serialNumber");
-            serial_number.children.push(XMLNode::Text(serial.to_string()));
+            serial_number
+                .children
+                .push(XMLNode::Text(serial.to_string()));
             elem.children.push(XMLNode::Element(serial_number));
         }
 
@@ -80,7 +94,9 @@ impl UpnpObject for Device {
             let mut icon = Element::new("icon");
 
             let mut mimetype = Element::new("mimetype");
-            mimetype.children.push(XMLNode::Text("image/png".to_string()));
+            mimetype
+                .children
+                .push(XMLNode::Text("image/png".to_string()));
             icon.children.push(XMLNode::Element(mimetype));
 
             let mut width = Element::new("width");
@@ -106,7 +122,9 @@ impl UpnpObject for Device {
         // presentationURL (optionnel)
         if let Some(url) = self.presentation_url() {
             let mut presentation_url = Element::new("presentationURL");
-            presentation_url.children.push(XMLNode::Text(url.to_string()));
+            presentation_url
+                .children
+                .push(XMLNode::Text(url.to_string()));
             elem.children.push(XMLNode::Element(presentation_url));
         }
 
diff --git a/pmoupnp/src/devices/device_registry.rs b/pmoupnp/src/devices/device_registry.rs
index 393611d4..cebc262e 100644
--- a/pmoupnp/src/devices/device_registry.rs
+++ b/pmoupnp/src/devices/device_registry.rs
@@ -4,14 +4,13 @@
 //! les `DeviceInstance` actifs, permettant l'introspection et la modification
 //! de l'état du serveur UPnP.
 
-use std::sync::{Arc, RwLock};
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use serde::{Serialize, Deserialize};
+use std::sync::{Arc, RwLock};
 
 use crate::{
-    devices::DeviceInstance,
+    UpnpObjectSet, UpnpTyped, UpnpTypedInstance, devices::DeviceInstance,
     state_variables::UpnpVariable,
-    UpnpTyped, UpnpObjectSet, UpnpTypedInstance,
 };
 
 /// Ensemble de DeviceInstance.
@@ -118,7 +117,8 @@ impl DeviceRegistry {
         }
 
         // Insérer dans le DeviceInstanceSet (par nom)
-        self.devices.insert(device)
+        self.devices
+            .insert(device)
             .map_err(|e| format!("Failed to register device in registry: {:?}", e))?;
 
         // Mettre à jour l'index UDN
@@ -225,7 +225,12 @@ impl DeviceRegistry {
     /// # Returns
     ///
     /// `Some(String)` contenant la valeur de la variable, `None` si non trouvée.
-    pub fn get_variable(&self, udn: &str, service_name: &str, variable_name: &str) -> Option<String> {
+    pub fn get_variable(
+        &self,
+        udn: &str,
+        service_name: &str,
+        variable_name: &str,
+    ) -> Option<String> {
         let device = self.get_device(udn)?;
         let service = device.get_service(service_name)?;
         let variable = service.get_variable(variable_name)?;
@@ -244,14 +249,23 @@ impl DeviceRegistry {
     /// # Returns
     ///
     /// `Ok(())` si la modification réussit, `Err(String)` en cas d'erreur.
-    pub async fn set_variable(&self, udn: &str, service_name: &str, variable_name: &str, value: &str) -> Result<(), String> {
-        let device = self.get_device(udn)
+    pub async fn set_variable(
+        &self,
+        udn: &str,
+        service_name: &str,
+        variable_name: &str,
+        value: &str,
+    ) -> Result<(), String> {
+        let device = self
+            .get_device(udn)
             .ok_or_else(|| format!("Device {} not found", udn))?;
 
-        let service = device.get_service(service_name)
+        let service = device
+            .get_service(service_name)
             .ok_or_else(|| format!("Service {} not found", service_name))?;
 
-        let variable = service.get_variable(variable_name)
+        let variable = service
+            .get_variable(variable_name)
             .ok_or_else(|| format!("Variable {} not found", variable_name))?;
 
         // Parser et valider la valeur selon le type de la variable
@@ -260,7 +274,9 @@ impl DeviceRegistry {
         let state_value = StateValue::from_string(value, &var_model.as_state_var_type())
             .map_err(|e| format!("Invalid value for variable {}: {:?}", variable_name, e))?;
 
-        variable.set_value(state_value).await
+        variable
+            .set_value(state_value)
+            .await
             .map_err(|e| format!("Failed to set value: {:?}", e))?;
 
         Ok(())
@@ -276,7 +292,11 @@ impl DeviceRegistry {
     /// # Returns
     ///
     /// `Some(HashMap<String, String>)` avec les variables (nom -> valeur), `None` si non trouvé.
-    pub fn get_service_variables(&self, udn: &str, service_name: &str) -> Option<HashMap<String, String>> {
+    pub fn get_service_variables(
+        &self,
+        udn: &str,
+        service_name: &str,
+    ) -> Option<HashMap<String, String>> {
         let device = self.get_device(udn)?;
         let service = device.get_service(service_name)?;
 
@@ -327,11 +347,13 @@ impl DeviceInfo {
             manufacturer: model.manufacturer().to_string(),
             model_name: model.model_name().to_string(),
             base_url: instance.base_url().to_string(),
-            services: instance.services()
+            services: instance
+                .services()
                 .iter()
                 .map(|s| ServiceInfo::from_instance(s))
                 .collect(),
-            devices: instance.devices()
+            devices: instance
+                .devices()
                 .iter()
                 .map(|d| DeviceInfo::from_instance(d))
                 .collect(),
@@ -361,12 +383,14 @@ impl ServiceInfo {
             name: instance.get_name().to_string(),
             service_type: instance.service_type(),
             service_id: instance.service_id(),
-            actions: instance.actions()
+            actions: instance
+                .actions()
                 .all()
                 .iter()
                 .map(|a| ActionInfo::from_instance(a))
                 .collect(),
-            variables: instance.statevariables()
+            variables: instance
+                .statevariables()
                 .all()
                 .iter()
                 .map(|v| VariableInfo::from_instance(v))
@@ -463,10 +487,7 @@ impl VariableInfo {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        devices::Device,
-        UpnpModel,
-    };
+    use crate::{UpnpModel, devices::Device};
 
     #[test]
     fn test_registry_creation() {
diff --git a/pmoupnp/src/devices/mod.rs b/pmoupnp/src/devices/mod.rs
index 64dbf960..963bbdd6 100644
--- a/pmoupnp/src/devices/mod.rs
+++ b/pmoupnp/src/devices/mod.rs
@@ -39,4 +39,7 @@ pub mod errors;
 
 pub use device::Device;
 pub use device_instance::DeviceInstance;
-pub use device_registry::{DeviceRegistry, DeviceInstanceSet, DeviceInfo, ServiceInfo, ActionInfo, ArgumentInfo, VariableInfo};
+pub use device_registry::{
+    ActionInfo, ArgumentInfo, DeviceInfo, DeviceInstanceSet, DeviceRegistry, ServiceInfo,
+    VariableInfo,
+};
diff --git a/pmoupnp/src/lib.rs b/pmoupnp/src/lib.rs
index 52cc8507..904829d7 100644
--- a/pmoupnp/src/lib.rs
+++ b/pmoupnp/src/lib.rs
@@ -1,24 +1,24 @@
-mod object_trait;
 mod object_set;
+mod object_trait;
 
-pub mod cache_registry;
-pub mod upnp_server;
-pub mod upnp_api;
 pub mod actions;
+pub mod cache_registry;
 pub mod devices;
 pub mod services;
 pub mod soap;
 pub mod ssdp;
 pub mod state_variables;
+pub mod upnp_api;
+pub mod upnp_server;
 pub mod value_ranges;
 pub mod variable_types;
 
-use std::{collections::HashMap, sync::Arc};
 use std::sync::RwLock;
+use std::{collections::HashMap, sync::Arc};
 
+pub use crate::cache_registry::{get_audio_cache, get_cover_cache};
 pub use crate::object_trait::*;
 pub use crate::upnp_server::UpnpServerExt;
-pub use crate::cache_registry::{get_cover_cache, get_audio_cache};
 
 #[derive(Debug, Clone)]
 pub struct UpnpObjectType {
@@ -35,4 +35,3 @@ pub struct UpnpObjectSet<T: UpnpTypedObject> {
 pub enum UpnpObjectSetError {
     AlreadyExists(String),
 }
-
diff --git a/pmoupnp/src/object_set.rs b/pmoupnp/src/object_set.rs
index b5651432..79eb6a9d 100644
--- a/pmoupnp/src/object_set.rs
+++ b/pmoupnp/src/object_set.rs
@@ -194,4 +194,4 @@ impl<T: UpnpTypedObject> UpnpObjectSet<T> {
         let guard = self.objects.read().unwrap();
         guard.values().cloned().collect()
     }
-}
\ No newline at end of file
+}
diff --git a/pmoupnp/src/object_trait.rs b/pmoupnp/src/object_trait.rs
index f7b0f2a8..3bd3af03 100644
--- a/pmoupnp/src/object_trait.rs
+++ b/pmoupnp/src/object_trait.rs
@@ -277,7 +277,7 @@ pub trait UpnpObject: Clone + Debug {
 pub trait UpnpModel: UpnpObject {
     /// Le type d'instance créée par ce modèle.
     type Instance: UpnpInstance<Model = Self>;
-    
+
     /// Crée une nouvelle instance à partir de ce modèle.
     ///
     /// # Returns
@@ -320,7 +320,7 @@ pub trait UpnpModel: UpnpObject {
 pub trait UpnpInstance: UpnpObject {
     /// Le type du modèle dont cette instance est dérivée.
     type Model: UpnpModel<Instance = Self>;
-      
+
     /// Crée une nouvelle instance à partir d'un modèle.
     ///
     /// # Arguments
@@ -331,7 +331,7 @@ pub trait UpnpInstance: UpnpObject {
     ///
     /// Une nouvelle instance initialisée depuis le modèle.
     fn new(model: &Self::Model) -> Self;
-    
+
     /// Indique que cet objet est une instance.
     ///
     /// # Returns
@@ -421,9 +421,9 @@ pub trait UpnpTypedObject: UpnpObject + UpnpTyped {}
 /// Ce trait ajoute la méthode [`get_model`](Self::get_model) pour accéder
 /// au modèle de l'instance. Les collections d'instances ([`UpnInstanceSet`])
 /// n'ont pas cette méthode car elles contiennent plusieurs instances.
-pub trait UpnpTypedInstance: UpnpTypedObject + UpnpInstance 
+pub trait UpnpTypedInstance: UpnpTypedObject + UpnpInstance
 where
-    Self::Model: UpnpModel<Instance = Self>
+    Self::Model: UpnpModel<Instance = Self>,
 {
     /// Retourne une référence vers le modèle dont cette instance est dérivée.
     ///
@@ -438,11 +438,11 @@ where
     ///
     /// ```ignore
     /// let instance = model.create_instance();
-    /// 
+    ///
     /// // Accéder aux propriétés du modèle depuis l'instance
     /// let model_ref = instance.get_model();
     /// println!("Instance du modèle: {}", model_ref.get_name());
-    /// 
+    ///
     /// // Vérifier les contraintes définies dans le modèle
     /// if let Some(range) = model_ref.get_range() {
     ///     println!("Plage autorisée: {:?}", range);
@@ -465,7 +465,6 @@ where
     fn get_model(&self) -> &Self::Model;
 }
 
-
 /// Trait marqueur pour les collections UPnP.
 ///
 /// Représente un ensemble (set) d'objets UPnP.
@@ -607,7 +606,6 @@ pub trait UpnpSet: UpnpObject + UpnpDeepClone {
 /// ```
 pub trait UpnpModelSet: UpnpSet + UpnpModel {}
 
-
 /// Trait marqueur pour les collections d'instances UPnP.
 ///
 /// Combine [`UpnpSet`] et [`UpnpInstance`] pour représenter une collection
@@ -626,7 +624,6 @@ pub trait UpnpModelSet: UpnpSet + UpnpModel {}
 /// C'est un *marker trait* (trait marqueur) sans méthodes supplémentaires.
 pub trait UpnInstanceSet: UpnpSet + UpnpInstance {}
 
-
 /// Implémentation automatique de [`UpnInstanceSet`] pour tous les types éligibles.
 ///
 /// Cette *blanket implementation* fournit automatiquement le trait [`UpnInstanceSet`]
@@ -667,10 +664,7 @@ pub trait UpnInstanceSet: UpnpSet + UpnpInstance {}
 ///     }
 /// }
 /// ```
-impl<T> UpnInstanceSet for T 
-where
-    T: UpnpSet + UpnpInstance
-{}
+impl<T> UpnInstanceSet for T where T: UpnpSet + UpnpInstance {}
 
 /// Implémentation automatique de [`UpnpTypedObject`] pour tous les types éligibles.
 ///
@@ -697,11 +691,7 @@ where
 ///     println!("{}", obj.get_name());
 /// }
 /// ```
-impl<T> UpnpTypedObject for T 
-where
-    T: UpnpObject + UpnpTyped
-{}
-
+impl<T> UpnpTypedObject for T where T: UpnpObject + UpnpTyped {}
 
 /// Implémentation automatique de [`UpnpModelSet`] pour tous les types éligibles.
 ///
@@ -756,8 +746,4 @@ where
 ///
 /// - [`UpnpModelSet`] : Collection de **modèles** (peut créer des instances)
 /// - [`UpnInstanceSet`] : Collection d'**instances** (créée depuis un modèle)
-impl<T> UpnpModelSet for T 
-where
-    T: UpnpSet + UpnpModel
-{}
-
+impl<T> UpnpModelSet for T where T: UpnpSet + UpnpModel {}
diff --git a/pmoupnp/src/services/errors.rs b/pmoupnp/src/services/errors.rs
index 5b7ab2d9..ed2ebc14 100644
--- a/pmoupnp/src/services/errors.rs
+++ b/pmoupnp/src/services/errors.rs
@@ -11,35 +11,35 @@ pub enum ServiceError {
     /// Erreur générale du service.
     #[error("Service error: {0}")]
     GeneralError(String),
-    
+
     /// Erreur de validation (paramètres invalides).
     #[error("Validation error: {0}")]
     ValidationError(String),
-    
+
     /// Erreur lors d'une opération sur un ensemble (Set).
     #[error("Set operation error: {0}")]
     SetError(String),
-    
+
     /// Erreur liée à une action.
     #[error("Action error: {0}")]
     ActionError(String),
-    
+
     /// Erreur liée à une variable d'état.
     #[error("State variable error: {0}")]
     StateVariableError(String),
-    
+
     /// Erreur de configuration.
     #[error("Configuration error: {0}")]
     ConfigError(String),
-    
+
     /// Erreur réseau ou HTTP.
     #[error("Network error: {0}")]
     NetworkError(String),
-    
+
     /// Erreur de sérialisation XML.
     #[error("XML serialization error: {0}")]
     XmlError(String),
-    
+
     /// Erreur lors du traitement SOAP.
     #[error("SOAP error: {0}")]
     SoapError(String),
@@ -59,4 +59,4 @@ impl From<crate::UpnpObjectSetError> for ServiceError {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/pmoupnp/src/services/mod.rs b/pmoupnp/src/services/mod.rs
index 700e0804..2ee9a943 100644
--- a/pmoupnp/src/services/mod.rs
+++ b/pmoupnp/src/services/mod.rs
@@ -52,7 +52,7 @@ pub use errors::ServiceError;
 pub use service_instance::ServiceInstance;
 use xmltree::{Element, EmitterConfig, XMLNode};
 
-use crate::{actions::ActionSet, state_variables::StateVariableSet, UpnpObject, UpnpObjectType};
+use crate::{UpnpObject, UpnpObjectType, actions::ActionSet, state_variables::StateVariableSet};
 
 /// Service UPnP (modèle).
 ///
@@ -470,18 +470,18 @@ impl Service {
         );
 
         let mut specversion = Element::new("specVersion");
-        let mut major= Element::new("major");
-        major.children
-            .push(XMLNode::Text("1".to_string()));
+        let mut major = Element::new("major");
+        major.children.push(XMLNode::Text("1".to_string()));
         specversion.children.push(XMLNode::Element(major));
         let mut minor = Element::new("minor");
-        minor.children
-            .push(XMLNode::Text("0".to_string()));
+        minor.children.push(XMLNode::Text("0".to_string()));
         specversion.children.push(XMLNode::Element(minor));
         scpd.children.push(XMLNode::Element(specversion));
 
-        scpd.children.push(XMLNode::Element(self.actions.to_xml_element()));
-        scpd.children.push(XMLNode::Element(self.state_table.to_xml_element()));
+        scpd.children
+            .push(XMLNode::Element(self.actions.to_xml_element()));
+        scpd.children
+            .push(XMLNode::Element(self.state_table.to_xml_element()));
 
         scpd
     }
@@ -519,7 +519,6 @@ impl Service {
             .expect("Failed to write XML");
 
         String::from_utf8(buf).expect("Invalid UTF-8")
-
     }
 }
 
diff --git a/pmoupnp/src/services/service_instance.rs b/pmoupnp/src/services/service_instance.rs
index ab0126db..6b6fda9f 100644
--- a/pmoupnp/src/services/service_instance.rs
+++ b/pmoupnp/src/services/service_instance.rs
@@ -35,6 +35,7 @@ use axum::{
     response::{IntoResponse, Response},
 };
 use bevy_reflect::Reflect;
+use quick_xml::escape::escape;
 use std::{
     collections::HashMap,
     sync::{Arc, Mutex, RwLock},
@@ -43,7 +44,6 @@ use std::{
 use tokio::time;
 use tracing::{debug, error, info, warn};
 use xmltree::{Element, EmitterConfig, XMLNode};
-use quick_xml::escape::escape;
 
 use crate::{
     UpnpInstance, UpnpObject, UpnpObjectType, UpnpTyped, UpnpTypedInstance,
@@ -671,7 +671,11 @@ impl ServiceInstance {
 
         let xml = String::from_utf8_lossy(&xml_output).to_string();
 
-        debug!("✅ SCPD generated for {} ({} bytes)", self.get_name(), xml.len());
+        debug!(
+            "✅ SCPD generated for {} ({} bytes)",
+            self.get_name(),
+            xml.len()
+        );
 
         (
             StatusCode::OK,
@@ -1050,13 +1054,14 @@ impl ServiceInstance {
 
     /// Sérialise une structure Reflect en XML simple.
     fn serialize_struct_to_xml(s: &dyn bevy_reflect::Struct) -> String {
-        use std::fmt::Write;
         use bevy_reflect::TypeInfo;
+        use std::fmt::Write;
 
         let mut xml = String::new();
 
         // Commencer par ouvrir la balise avec le nom du type
-        let type_name = s.get_represented_type_info()
+        let type_name = s
+            .get_represented_type_info()
             .and_then(|ti| {
                 if let TypeInfo::Struct(si) = ti {
                     Some(si.type_path_table().short_path())
@@ -1237,9 +1242,9 @@ async fn event_sub_handler(
 /// - Échec de l'exécution de l'action
 async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: String) -> Response {
     use crate::{
-        soap::{parse_soap_action, build_soap_response, build_soap_fault, error_codes},
-        variable_types::{StateValue, UpnpVarType},
         UpnpTypedInstance,
+        soap::{build_soap_fault, build_soap_response, error_codes, parse_soap_action},
+        variable_types::{StateValue, UpnpVarType},
     };
     use std::collections::HashMap;
     use tracing::debug;
@@ -1259,9 +1264,13 @@ async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: Str
             ).unwrap_or_else(|_| String::from("<?xml version=\"1.0\"?><s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body><s:Fault><faultcode>s:Server</faultcode><faultstring>Internal Error</faultstring></s:Fault></s:Body></s:Envelope>"));
             return (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                [(axum::http::header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],
+                [(
+                    axum::http::header::CONTENT_TYPE,
+                    "text/xml; charset=\"utf-8\"",
+                )],
                 fault_xml,
-            ).into_response();
+            )
+                .into_response();
         }
     };
 
@@ -1281,9 +1290,13 @@ async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: Str
             ).unwrap_or_else(|_| String::from("<?xml version=\"1.0\"?><s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body><s:Fault><faultcode>s:Server</faultcode><faultstring>Internal Error</faultstring></s:Fault></s:Body></s:Envelope>"));
             return (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                [(axum::http::header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],
+                [(
+                    axum::http::header::CONTENT_TYPE,
+                    "text/xml; charset=\"utf-8\"",
+                )],
                 fault_xml,
-            ).into_response();
+            )
+                .into_response();
         }
     };
 
@@ -1311,9 +1324,13 @@ async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: Str
                         ).unwrap_or_else(|_| String::from("<?xml version=\"1.0\"?><s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body><s:Fault><faultcode>s:Server</faultcode><faultstring>Internal Error</faultstring></s:Fault></s:Body></s:Envelope>"));
                         return (
                             StatusCode::BAD_REQUEST,
-                            [(axum::http::header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],
+                            [(
+                                axum::http::header::CONTENT_TYPE,
+                                "text/xml; charset=\"utf-8\"",
+                            )],
                             fault_xml,
-                        ).into_response();
+                        )
+                            .into_response();
                     }
                 }
             }
@@ -1334,7 +1351,8 @@ async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: Str
                 let arg_model = arg_inst.as_ref().get_model();
                 if arg_model.is_out() {
                     if let Some(reflect_value) = output_data.get(arg_inst.get_name()) {
-                        let soap_string = ServiceInstance::reflect_to_string(reflect_value.as_ref());
+                        let soap_string =
+                            ServiceInstance::reflect_to_string(reflect_value.as_ref());
                         soap_values.insert(arg_inst.get_name().to_string(), soap_string);
                     }
                 }
@@ -1356,9 +1374,13 @@ async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: Str
 
             (
                 StatusCode::OK,
-                [(axum::http::header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],
+                [(
+                    axum::http::header::CONTENT_TYPE,
+                    "text/xml; charset=\"utf-8\"",
+                )],
                 response_xml,
-            ).into_response()
+            )
+                .into_response()
         }
         Err(e) => {
             error!("❌ Action execution failed: {:?}", e);
@@ -1370,9 +1392,13 @@ async fn control_handler(State(instance): State<Arc<ServiceInstance>>, body: Str
             ).unwrap_or_else(|_| String::from("<?xml version=\"1.0\"?><s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body><s:Fault><faultcode>s:Server</faultcode><faultstring>Internal Error</faultstring></s:Fault></s:Body></s:Envelope>"));
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                [(axum::http::header::CONTENT_TYPE, "text/xml; charset=\"utf-8\"")],
+                [(
+                    axum::http::header::CONTENT_TYPE,
+                    "text/xml; charset=\"utf-8\"",
+                )],
                 fault_xml,
-            ).into_response()
+            )
+                .into_response()
         }
     }
 }
@@ -1448,7 +1474,7 @@ mod tests {
         }
 
         let person = Person {
-            name: "John <Doe>".to_string(),  // Test XML escaping
+            name: "John <Doe>".to_string(), // Test XML escaping
             age: 30,
             address: Address {
                 street: "123 Main St & Ave".to_string(),
diff --git a/pmoupnp/src/services/service_methods.rs b/pmoupnp/src/services/service_methods.rs
index 6480d1bd..4d4a6120 100644
--- a/pmoupnp/src/services/service_methods.rs
+++ b/pmoupnp/src/services/service_methods.rs
@@ -14,8 +14,8 @@
 use xmltree::{Element, XMLNode};
 
 use crate::{
+    UpnpModel, UpnpObject, UpnpObjectType, UpnpTyped,
     services::{Service, ServiceInstance},
-    UpnpObject, UpnpModel, UpnpTyped, UpnpObjectType,
 };
 
 impl std::fmt::Display for Service {
@@ -36,7 +36,9 @@ impl UpnpObject for Service {
 
         // serviceType
         let mut service_type = Element::new("serviceType");
-        service_type.children.push(XMLNode::Text(self.service_type()));
+        service_type
+            .children
+            .push(XMLNode::Text(self.service_type()));
         elem.children.push(XMLNode::Element(service_type));
 
         // serviceId
@@ -51,7 +53,9 @@ impl UpnpObject for Service {
 
         // controlURL
         let mut controlURL = Element::new("controlURL");
-        controlURL.children.push(XMLNode::Text(self.control_route()));
+        controlURL
+            .children
+            .push(XMLNode::Text(self.control_route()));
         elem.children.push(XMLNode::Element(controlURL));
 
         // eventSubURL
@@ -65,4 +69,4 @@ impl UpnpObject for Service {
 
 impl UpnpModel for Service {
     type Instance = ServiceInstance;
-}
\ No newline at end of file
+}
diff --git a/pmoupnp/src/soap/builder.rs b/pmoupnp/src/soap/builder.rs
index 7e9d4c7e..3b0a7ca8 100644
--- a/pmoupnp/src/soap/builder.rs
+++ b/pmoupnp/src/soap/builder.rs
@@ -88,12 +88,8 @@ mod tests {
     fn test_build_empty_response() {
         let values = HashMap::new();
 
-        let xml = build_soap_response(
-            "urn:schemas-upnp-org:service:AVTransport:1",
-            "Stop",
-            values,
-        )
-        .unwrap();
+        let xml = build_soap_response("urn:schemas-upnp-org:service:AVTransport:1", "Stop", values)
+            .unwrap();
 
         assert!(xml.contains("StopResponse"));
         assert!(xml.contains("xmlns:u=\"urn:schemas-upnp-org:service:AVTransport:1\""));
diff --git a/pmoupnp/src/soap/envelope.rs b/pmoupnp/src/soap/envelope.rs
index 3ab19418..4e66b591 100644
--- a/pmoupnp/src/soap/envelope.rs
+++ b/pmoupnp/src/soap/envelope.rs
@@ -29,10 +29,7 @@ pub struct SoapBody {
 impl SoapEnvelope {
     /// Crée une nouvelle enveloppe SOAP
     pub fn new(body: SoapBody) -> Self {
-        Self {
-            header: None,
-            body,
-        }
+        Self { header: None, body }
     }
 
     /// Crée une nouvelle enveloppe avec header
diff --git a/pmoupnp/src/soap/fault.rs b/pmoupnp/src/soap/fault.rs
index b79ce855..917bbe85 100644
--- a/pmoupnp/src/soap/fault.rs
+++ b/pmoupnp/src/soap/fault.rs
@@ -102,17 +102,13 @@ pub fn build_soap_fault(
         error_code_elem
             .children
             .push(XMLNode::Text(code.to_string()));
-        upnp_error
-            .children
-            .push(XMLNode::Element(error_code_elem));
+        upnp_error.children.push(XMLNode::Element(error_code_elem));
 
         let mut error_desc_elem = Element::new("errorDescription");
         error_desc_elem
             .children
             .push(XMLNode::Text(desc.to_string()));
-        upnp_error
-            .children
-            .push(XMLNode::Element(error_desc_elem));
+        upnp_error.children.push(XMLNode::Element(error_desc_elem));
 
         detail.children.push(XMLNode::Element(upnp_error));
         fault.children.push(XMLNode::Element(detail));
diff --git a/pmoupnp/src/soap/mod.rs b/pmoupnp/src/soap/mod.rs
index 06dd7868..a34107d5 100644
--- a/pmoupnp/src/soap/mod.rs
+++ b/pmoupnp/src/soap/mod.rs
@@ -48,15 +48,15 @@
 //! ).unwrap();
 //! ```
 
-mod envelope;
-mod parser;
 mod builder;
+mod envelope;
 mod fault;
+mod parser;
 
-pub use envelope::{SoapEnvelope, SoapHeader, SoapBody};
-pub use parser::{parse_soap_action, SoapAction};
 pub use builder::build_soap_response;
+pub use envelope::{SoapBody, SoapEnvelope, SoapHeader};
 pub use fault::{SoapFault, build_soap_fault};
+pub use parser::{SoapAction, parse_soap_action};
 
 /// Codes d'erreur SOAP UPnP standards
 pub mod error_codes {
diff --git a/pmoupnp/src/soap/parser.rs b/pmoupnp/src/soap/parser.rs
index d5d243f9..c819a8fe 100644
--- a/pmoupnp/src/soap/parser.rs
+++ b/pmoupnp/src/soap/parser.rs
@@ -55,17 +55,16 @@ pub fn parse_soap_envelope(xml: &[u8]) -> Result<SoapEnvelope, SoapParseError> {
         .get_child("Header")
         .or_else(|| root.children.iter().find_map(|n| n.as_element()))
         .filter(|e| e.name.ends_with("Header"))
-        .map(|e| SoapHeader {
-            content: e.clone(),
-        });
+        .map(|e| SoapHeader { content: e.clone() });
 
     // Extraire Body (obligatoire)
     let body_elem = root
         .get_child("Body")
-        .or_else(|| root.children.iter().find_map(|n| {
-            n.as_element()
-                .filter(|e| e.name.ends_with("Body"))
-        }))
+        .or_else(|| {
+            root.children
+                .iter()
+                .find_map(|n| n.as_element().filter(|e| e.name.ends_with("Body")))
+        })
         .ok_or(SoapParseError::MissingBody)?;
 
     let body = SoapBody {
diff --git a/pmoupnp/src/ssdp/device.rs b/pmoupnp/src/ssdp/device.rs
index 2b1af1ec..eb36b137 100644
--- a/pmoupnp/src/ssdp/device.rs
+++ b/pmoupnp/src/ssdp/device.rs
@@ -22,12 +22,7 @@ pub struct SsdpDevice {
 
 impl SsdpDevice {
     /// Crée un nouveau device SSDP
-    pub fn new(
-        uuid: String,
-        device_type: String,
-        location: String,
-        server: String,
-    ) -> Self {
+    pub fn new(uuid: String, device_type: String, location: String, server: String) -> Self {
         // Construction automatique des NTs standards
         let notification_types = vec![
             format!("uuid:{}", uuid),
diff --git a/pmoupnp/src/ssdp/server.rs b/pmoupnp/src/ssdp/server.rs
index 4f729242..1b12a238 100644
--- a/pmoupnp/src/ssdp/server.rs
+++ b/pmoupnp/src/ssdp/server.rs
@@ -1,6 +1,6 @@
 //! Serveur SSDP
 
-use super::{SsdpDevice, SSDP_MULTICAST_ADDR, SSDP_PORT, MAX_AGE};
+use super::{MAX_AGE, SSDP_MULTICAST_ADDR, SSDP_PORT, SsdpDevice};
 use std::collections::HashMap;
 use std::net::{SocketAddr, UdpSocket};
 use std::sync::{Arc, RwLock};
diff --git a/pmoupnp/src/state_variables/instance_methods.rs b/pmoupnp/src/state_variables/instance_methods.rs
index d206b63d..dab1176b 100644
--- a/pmoupnp/src/state_variables/instance_methods.rs
+++ b/pmoupnp/src/state_variables/instance_methods.rs
@@ -7,10 +7,10 @@ use std::sync::RwLock;
 use xmltree::Element;
 
 use crate::{
-    object_trait::{UpnpInstance, UpnpObject}, 
-    state_variables::{StateVarInstance, StateVariable, UpnpVariable}, 
-    variable_types::{StateValue, StateValueError, UpnpVarType}, 
-    UpnpObjectType, UpnpTyped, UpnpTypedInstance
+    UpnpObjectType, UpnpTyped, UpnpTypedInstance,
+    object_trait::{UpnpInstance, UpnpObject},
+    state_variables::{StateVarInstance, StateVariable, UpnpVariable},
+    variable_types::{StateValue, StateValueError, UpnpVarType},
 };
 
 impl UpnpVariable for StateVarInstance {
@@ -49,7 +49,6 @@ impl UpnpInstance for StateVarInstance {
             reflexive_cache: RwLock::new(None),
         }
     }
-
 }
 
 impl UpnpTyped for StateVarInstance {
@@ -59,7 +58,6 @@ impl UpnpTyped for StateVarInstance {
 }
 
 impl UpnpTypedInstance for StateVarInstance {
-
     fn get_model(&self) -> &Self::Model {
         &self.model
     }
@@ -122,7 +120,7 @@ impl StateVarInstance {
         // Validation du type
         if self.as_state_var_type() != new_value.as_state_var_type() {
             return Err(StateValueError::TypeError(
-                "Value type mismatch".to_string()
+                "Value type mismatch".to_string(),
             ));
         }
 
@@ -191,7 +189,9 @@ impl StateVarInstance {
     /// let reflected = var.reflexive_value();
     /// // reflected peut maintenant être inspecté avec l'API Reflect
     /// ```
-    pub fn reflexive_value(&self) -> Result<Arc<dyn Reflect>, crate::state_variables::StateVariableError> {
+    pub fn reflexive_value(
+        &self,
+    ) -> Result<Arc<dyn Reflect>, crate::state_variables::StateVariableError> {
         // Vérifier si on a un cache valide
         {
             let cache = self.reflexive_cache.read().unwrap();
@@ -256,7 +256,9 @@ impl StateVarInstance {
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to parse value '{}' for variable '{}': {:?}, using raw string",
-                                s, self.get_name(), e
+                                s,
+                                self.get_name(),
+                                e
                             );
                         }
                     }
@@ -285,7 +287,10 @@ impl StateVarInstance {
     /// - La conversion Reflect → StateValue échoue
     /// - Le marshalling échoue
     /// - La mise à jour de la valeur échoue
-    pub async fn set_reflect_value(&self, reflect_value: Box<dyn Reflect>) -> Result<(), StateValueError> {
+    pub async fn set_reflect_value(
+        &self,
+        reflect_value: Box<dyn Reflect>,
+    ) -> Result<(), StateValueError> {
         use crate::variable_types::StateVarType;
 
         // Convertir Reflect → StateValue
@@ -297,19 +302,18 @@ impl StateVarInstance {
                     Ok(temp_value) => {
                         // Utiliser le marshal pour obtenir la String marshallée
                         match marshal(&temp_value) {
-                            Ok(marshalled_string) => {
-                                StateValue::String(marshalled_string)
-                            },
+                            Ok(marshalled_string) => StateValue::String(marshalled_string),
                             Err(e) => {
                                 tracing::warn!(
                                     "Failed to marshal value for variable '{}': {:?}, using standard conversion",
-                                    self.get_name(), e
+                                    self.get_name(),
+                                    e
                                 );
                                 // Fallback
                                 temp_value
                             }
                         }
-                    },
+                    }
                     Err(e) => return Err(e),
                 }
             } else {
diff --git a/pmoupnp/src/state_variables/mod.rs b/pmoupnp/src/state_variables/mod.rs
index a7d58d58..ca423ff3 100644
--- a/pmoupnp/src/state_variables/mod.rs
+++ b/pmoupnp/src/state_variables/mod.rs
@@ -1,15 +1,12 @@
 mod errors;
 mod instance_methods;
 mod macros;
-mod variable_methods;
-mod var_set_methods;
 mod var_inst_set_methods;
+mod var_set_methods;
+mod variable_methods;
 mod variable_trait;
 
-use std::{
-    collections::HashMap,
-    sync::Arc,
-};
+use std::{collections::HashMap, sync::Arc};
 
 pub use crate::state_variables::variable_trait::UpnpVariable;
 use bevy_reflect::Reflect;
@@ -18,9 +15,9 @@ pub use errors::StateVariableError;
 use std::sync::RwLock;
 
 use crate::{
-    value_ranges::ValueRange, 
-    variable_types::{StateValue, StateVarType}, 
     UpnpObjectSet, UpnpObjectType,
+    value_ranges::ValueRange,
+    variable_types::{StateValue, StateVarType},
 };
 
 /// Type pour les fonctions de condition d'événement
@@ -65,4 +62,3 @@ pub struct StateVarInstance {
 }
 
 pub type StateVarInstanceSet = UpnpObjectSet<StateVarInstance>;
-
diff --git a/pmoupnp/src/state_variables/var_inst_set_methods.rs b/pmoupnp/src/state_variables/var_inst_set_methods.rs
index e5d55dc3..667f6030 100644
--- a/pmoupnp/src/state_variables/var_inst_set_methods.rs
+++ b/pmoupnp/src/state_variables/var_inst_set_methods.rs
@@ -3,14 +3,17 @@ use std::collections::HashMap;
 use std::sync::RwLock;
 use xmltree::{Element, XMLNode};
 
-use crate::{state_variables::{StateVarInstanceSet, StateVariableSet}, UpnpObject};
+use crate::{
+    UpnpObject,
+    state_variables::{StateVarInstanceSet, StateVariableSet},
+};
 
 use crate::UpnpInstance;
 
 impl UpnpObject for StateVarInstanceSet {
     fn to_xml_element(&self) -> Element {
         let mut elem = Element::new("serviceStateTable");
-        
+
         for state_var in self.all() {
             let state_var_elem = state_var.to_xml_element(); // retourne un <stateVariable> complet
             elem.children.push(XMLNode::Element(state_var_elem));
@@ -24,10 +27,8 @@ impl UpnpInstance for StateVarInstanceSet {
     type Model = StateVariableSet;
 
     fn new(_: &StateVariableSet) -> Self {
-        Self { objects: RwLock::new(HashMap::new()) }
+        Self {
+            objects: RwLock::new(HashMap::new()),
+        }
     }
-
-
 }
-
-
diff --git a/pmoupnp/src/state_variables/var_set_methods.rs b/pmoupnp/src/state_variables/var_set_methods.rs
index 14b8c836..0fa68719 100644
--- a/pmoupnp/src/state_variables/var_set_methods.rs
+++ b/pmoupnp/src/state_variables/var_set_methods.rs
@@ -1,13 +1,15 @@
 use xmltree::{Element, XMLNode};
 
-use crate::{object_trait::UpnpModel, state_variables::{StateVarInstanceSet, StateVariableSet}, UpnpObject};
-
+use crate::{
+    UpnpObject,
+    object_trait::UpnpModel,
+    state_variables::{StateVarInstanceSet, StateVariableSet},
+};
 
 impl UpnpObject for StateVariableSet {
-
     fn to_xml_element(&self) -> Element {
         let mut elem = Element::new("serviceStateTable");
-        
+
         for state_var in self.all() {
             let state_var_elem = state_var.to_xml_element(); // retourne un <stateVariable> complet
             elem.children.push(XMLNode::Element(state_var_elem));
@@ -15,11 +17,8 @@ impl UpnpObject for StateVariableSet {
 
         elem
     }
-
 }
 
 impl UpnpModel for StateVariableSet {
     type Instance = StateVarInstanceSet;
 }
-
-
diff --git a/pmoupnp/src/state_variables/variable_methods.rs b/pmoupnp/src/state_variables/variable_methods.rs
index d9299b0d..f4174e30 100644
--- a/pmoupnp/src/state_variables/variable_methods.rs
+++ b/pmoupnp/src/state_variables/variable_methods.rs
@@ -1,8 +1,4 @@
-use std::{
-    collections::HashMap,
-    fmt,
-    sync::Arc,
-};
+use std::{collections::HashMap, fmt, sync::Arc};
 
 use std::sync::RwLock;
 use xmltree::{Element, XMLNode};
@@ -112,17 +108,13 @@ impl Clone for StateVariable {
         // clone safe des structures protégées par RwLock en prenant un read lock
         let event_conditions_clone = {
             // si le lock est "poisoned" on panic - tu peux adapter la gestion si tu veux
-            let guard = self
-                .event_conditions
-                .read().unwrap();
+            let guard = self.event_conditions.read().unwrap();
             // nécessite que Key: Clone, Value: Clone
             Arc::new(RwLock::new(guard.clone()))
         };
 
         let allowed_values_clone = {
-            let guard = self
-                .allowed_values
-                .read().unwrap();
+            let guard = self.allowed_values.read().unwrap();
             Arc::new(RwLock::new(guard.clone()))
         };
 
@@ -154,20 +146,14 @@ impl fmt::Debug for StateVariable {
             .field("modifiable", &self.modifiable)
             .field(
                 "event_conditions",
-                &format_args!(
-                    "len={}",
-                    self.event_conditions.read().unwrap().len()
-                ),
+                &format_args!("len={}", self.event_conditions.read().unwrap().len()),
             )
             .field("description", &self.description)
             .field("default_value", &self.default_value)
             .field("value_range", &self.value_range)
             .field(
                 "allowed_values",
-                &format_args!(
-                    "len={}",
-                    self.allowed_values.read().unwrap().len()
-                ),
+                &format_args!("len={}", self.allowed_values.read().unwrap().len()),
             )
             .field("send_events", &self.send_events)
             .field(
@@ -332,9 +318,7 @@ impl StateVariable {
     }
 
     pub fn extend_allowed_values(&mut self, values: &[StateValue]) -> Result<(), StateValueError> {
-        let mut av = self
-            .allowed_values
-            .write().unwrap();
+        let mut av = self.allowed_values.write().unwrap();
 
         for v in values {
             if self.as_state_var_type() == v.as_state_var_type() {
@@ -350,9 +334,7 @@ impl StateVariable {
     }
 
     pub fn push_allowed_value(&mut self, value: &StateValue) -> Result<(), StateValueError> {
-        let mut av = self
-            .allowed_values
-            .write().unwrap();
+        let mut av = self.allowed_values.write().unwrap();
 
         if self.as_state_var_type() == value.as_state_var_type() {
             av.push(value.clone());
diff --git a/pmoupnp/src/state_variables/variable_trait.rs b/pmoupnp/src/state_variables/variable_trait.rs
index 07b19a48..302cde9c 100644
--- a/pmoupnp/src/state_variables/variable_trait.rs
+++ b/pmoupnp/src/state_variables/variable_trait.rs
@@ -216,9 +216,7 @@ pub trait UpnpVariable {
     ///
     /// Retourne `false` si le lock est empoisonné (poisoned).
     fn has_allowed_values(&self) -> bool {
-        let guard = self.get_definition()
-            .allowed_values
-            .read().unwrap();
+        let guard = self.get_definition().allowed_values.read().unwrap();
 
         !guard.is_empty()
     }
@@ -250,9 +248,7 @@ pub trait UpnpVariable {
     /// retourne `false`. Utilisez [`has_allowed_values`](Self::has_allowed_values)
     /// pour distinguer "pas de liste" de "valeur non autorisée".
     fn is_an_allowed_value(&self, value: &StateValue) -> bool {
-        let guard = self.get_definition()
-            .allowed_values
-            .read().unwrap();
+        let guard = self.get_definition().allowed_values.read().unwrap();
 
         guard.contains(value)
     }
diff --git a/pmoupnp/src/upnp_api.rs b/pmoupnp/src/upnp_api.rs
index d32c9f44..02449464 100644
--- a/pmoupnp/src/upnp_api.rs
+++ b/pmoupnp/src/upnp_api.rs
@@ -9,17 +9,13 @@
 //! - `GET /api/upnp/devices/:udn` - Détails d'un device
 //! - `GET /api/upnp/devices/:udn/services/:service/variables` - Variables d'un service
 
+use crate::{UpnpTyped, UpnpTypedInstance, state_variables::UpnpVariable, upnp_server};
 use axum::{
+    Router,
     extract::Path,
     http::StatusCode,
     response::{IntoResponse, Json},
     routing::get,
-    Router,
-};
-use crate::{
-    state_variables::UpnpVariable,
-    upnp_server,
-    UpnpTyped, UpnpTypedInstance,
 };
 use pmoserver::Server;
 use serde_json::json;
@@ -65,7 +61,8 @@ async fn get_device(Path(udn): Path<String>) -> impl IntoResponse {
                 .iter()
                 .map(|s| {
                     // Collecter les actions
-                    let actions: Vec<_> = s.actions()
+                    let actions: Vec<_> = s
+                        .actions()
                         .all()
                         .iter()
                         .map(|a| {
@@ -91,12 +88,13 @@ async fn get_device(Path(udn): Path<String>) -> impl IntoResponse {
                                     json!({
                                         "name": arg.get_name(),
                                         "related_state_variable": model.state_variable().get_name()
-                                    })
-                                })
-                                .collect();
+                            })
+                        })
+                        .collect();
 
                             json!({
                                 "name": a.get_name(),
+                                "stateless": !a.is_stateful(),
                                 "in_arguments": in_args,
                                 "out_arguments": out_args
                             })
@@ -143,7 +141,9 @@ async fn get_device(Path(udn): Path<String>) -> impl IntoResponse {
 /// Handler : Variables d'un service.
 ///
 /// GET /api/upnp/devices/:udn/services/:service/variables
-async fn get_service_variables(Path((udn, service_name)): Path<(String, String)>) -> impl IntoResponse {
+async fn get_service_variables(
+    Path((udn, service_name)): Path<(String, String)>,
+) -> impl IntoResponse {
     match upnp_server::get_device_by_udn(&udn) {
         Some(device) => match device.get_service(&service_name) {
             Some(service) => {
@@ -168,7 +168,7 @@ async fn get_service_variables(Path((udn, service_name)): Path<(String, String)>
                         let (min, max) = if let Some(range) = model.get_range() {
                             (
                                 Some(range.get_minimum().to_string()),
-                                Some(range.get_maximum().to_string())
+                                Some(range.get_maximum().to_string()),
                             )
                         } else {
                             (None, None)
diff --git a/pmoupnp/src/upnp_server.rs b/pmoupnp/src/upnp_server.rs
index 8e3cca05..fc4abc21 100644
--- a/pmoupnp/src/upnp_server.rs
+++ b/pmoupnp/src/upnp_server.rs
@@ -18,40 +18,37 @@
 //!     + DeviceRegistry (thread_local storage)
 //! ```
 
+use once_cell::sync::Lazy;
 use std::sync::Arc;
 use std::sync::RwLock;
-use once_cell::sync::Lazy;
 
 use pmoserver::Server;
 use utoipa::OpenApi;
 
-use crate::devices::errors::DeviceError;
-use crate::devices::{Device, DeviceInstance, DeviceRegistry};
 use crate::UpnpModel;
 use crate::cache_registry::CACHE_REGISTRY;
+use crate::devices::errors::DeviceError;
+use crate::devices::{Device, DeviceInstance, DeviceRegistry};
 use crate::ssdp::SsdpServer;
 use crate::upnp_api::UpnpApiExt;
 
-use pmocovers::Cache as CoverCache;
 use pmoaudiocache::Cache as AudioCache;
-use pmoutils::{find_process_using_port, TransportProtocol};
+use pmocovers::Cache as CoverCache;
+use pmoutils::{TransportProtocol, find_process_using_port};
 
 /// Registre de devices global et thread-safe.
 ///
 /// Utilise Lazy pour une initialisation paresseuse et RwLock pour le partage entre threads.
 /// Ceci permet aux API handlers (qui s'exécutent dans des threads différents) d'accéder
 /// au même registre de devices.
-static DEVICE_REGISTRY: Lazy<RwLock<DeviceRegistry>> = Lazy::new(|| {
-    RwLock::new(DeviceRegistry::new())
-});
+static DEVICE_REGISTRY: Lazy<RwLock<DeviceRegistry>> =
+    Lazy::new(|| RwLock::new(DeviceRegistry::new()));
 
 /// Serveur SSDP global et thread-safe.
 ///
 /// Utilise Lazy pour une initialisation paresseuse et RwLock pour le partage entre threads.
 /// Permet l'annonce automatique des devices UPnP sur le réseau.
-static SSDP_SERVER: Lazy<RwLock<Option<SsdpServer>>> = Lazy::new(|| {
-    RwLock::new(None)
-});
+static SSDP_SERVER: Lazy<RwLock<Option<SsdpServer>>> = Lazy::new(|| RwLock::new(None));
 
 /// Trait pour étendre un serveur avec des fonctionnalités UPnP.
 ///
@@ -97,7 +94,10 @@ pub trait UpnpServerExt {
     /// # Returns
     ///
     /// L'instance du device créée et enregistrée.
-    async fn register_device(&mut self, device: Arc<Device>) -> Result<Arc<DeviceInstance>, DeviceError>;
+    async fn register_device(
+        &mut self,
+        device: Arc<Device>,
+    ) -> Result<Arc<DeviceInstance>, DeviceError>;
 
     /// Retourne le nombre de devices enregistrés.
     fn device_count(&self) -> usize;
@@ -123,8 +123,11 @@ pub trait UpnpServerExt {
     /// # Returns
     ///
     /// Instance partagée du cache
-    async fn init_cover_cache(&mut self, cache_dir: &str, limit: usize)
-        -> Result<Arc<CoverCache>, anyhow::Error>;
+    async fn init_cover_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> Result<Arc<CoverCache>, anyhow::Error>;
 
     /// Initialiser le cache audio centralisé
     ///
@@ -139,8 +142,11 @@ pub trait UpnpServerExt {
     /// # Returns
     ///
     /// Instance partagée du cache
-    async fn init_audio_cache(&mut self, cache_dir: &str, limit: usize)
-        -> Result<Arc<AudioCache>, anyhow::Error>;
+    async fn init_audio_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> Result<Arc<AudioCache>, anyhow::Error>;
 
     /// Initialiser les caches depuis la configuration
     ///
@@ -150,8 +156,7 @@ pub trait UpnpServerExt {
     /// # Returns
     ///
     /// Tuple (cache de couvertures, cache audio)
-    async fn init_caches(&mut self)
-        -> Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error>;
+    async fn init_caches(&mut self) -> Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error>;
 
     /// Récupérer le cache de couvertures
     fn cover_cache(&self) -> Option<Arc<CoverCache>>;
@@ -219,17 +224,32 @@ pub trait UpnpServerExt {
 
 // Implémentation du trait UpnpServer pour pmoserver::Server
 impl UpnpServerExt for Server {
-    async fn register_device(&mut self, device: Arc<Device>) -> Result<Arc<DeviceInstance>, DeviceError> {
+    async fn register_device(
+        &mut self,
+        device: Arc<Device>,
+    ) -> Result<Arc<DeviceInstance>, DeviceError> {
         use tracing::info;
 
         // Créer l'instance (retourne déjà un Arc<DeviceInstance>)
-        let di = device.create_instance();
+        let mut di = device.create_instance();
+
+        // Normaliser la base URL HTTP avant tout enregistrement.
+        let server_base_url = self.base_url();
+        if let Some(instance) = Arc::get_mut(&mut di) {
+            instance.set_server_base_url(server_base_url);
+        } else {
+            tracing::warn!(
+                "Unable to set base URL on device {} before registration; keeping existing value",
+                di.udn()
+            );
+        }
 
         // Enregistrer les URLs dans le serveur web
         di.register_urls(self).await?;
 
         // Ajouter au registre pour l'introspection
-        DEVICE_REGISTRY.write()
+        DEVICE_REGISTRY
+            .write()
             .unwrap()
             .register(di.clone())
             .map_err(|e| DeviceError::UrlRegistrationError(e))?;
@@ -261,10 +281,13 @@ impl UpnpServerExt for Server {
 
     // ========= Cache Management Implementation =========
 
-    async fn init_cover_cache(&mut self, cache_dir: &str, limit: usize)
-        -> Result<Arc<CoverCache>, anyhow::Error> {
+    async fn init_cover_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> Result<Arc<CoverCache>, anyhow::Error> {
+        use pmocache::pmoserver_ext::{create_api_router, create_file_router_with_generator};
         use pmocovers::new_cache;
-        use pmocache::pmoserver_ext::{create_file_router_with_generator, create_api_router};
 
         let base_url = self.info().base_url.clone();
         let cache = Arc::new(new_cache(cache_dir, limit)?);
@@ -279,7 +302,13 @@ impl UpnpServerExt for Server {
                         match pmocovers::webp::generate_variant(&cache, &pk, size).await {
                             Ok(data) => return Some(data),
                             Err(e) => {
-                                tracing::warn!("Cannot generate variant {}x{} for {}: {}", size, size, pk, e);
+                                tracing::warn!(
+                                    "Cannot generate variant {}x{} for {}: {}",
+                                    size,
+                                    size,
+                                    pk,
+                                    e
+                                );
                                 return None;
                             }
                         }
@@ -288,11 +317,8 @@ impl UpnpServerExt for Server {
                 })
             });
 
-        let file_router = create_file_router_with_generator(
-            cache.clone(),
-            "image/webp",
-            Some(variant_generator)
-        );
+        let file_router =
+            create_file_router_with_generator(cache.clone(), "image/webp", Some(variant_generator));
         self.add_router("/", file_router).await;
 
         // API REST générique (pmocache)
@@ -310,10 +336,13 @@ impl UpnpServerExt for Server {
         Ok(cache)
     }
 
-    async fn init_audio_cache(&mut self, cache_dir: &str, limit: usize)
-        -> Result<Arc<AudioCache>, anyhow::Error> {
+    async fn init_audio_cache(
+        &mut self,
+        cache_dir: &str,
+        limit: usize,
+    ) -> Result<Arc<AudioCache>, anyhow::Error> {
         use pmoaudiocache::new_cache;
-        use pmocache::pmoserver_ext::{create_file_router, create_api_router};
+        use pmocache::pmoserver_ext::{create_api_router, create_file_router};
 
         let base_url = self.info().base_url.clone();
         let cache = Arc::new(new_cache(cache_dir, limit)?);
@@ -337,19 +366,22 @@ impl UpnpServerExt for Server {
         Ok(cache)
     }
 
-    async fn init_caches(&mut self)
-        -> Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error> {
+    async fn init_caches(&mut self) -> Result<(Arc<CoverCache>, Arc<AudioCache>), anyhow::Error> {
         let config = pmoconfig::get_config();
 
-        let cover_cache = self.init_cover_cache(
-            &config.get_cover_cache_dir()?,
-            config.get_cover_cache_size()?
-        ).await?;
+        let cover_cache = self
+            .init_cover_cache(
+                &config.get_cover_cache_dir()?,
+                config.get_cover_cache_size()?,
+            )
+            .await?;
 
-        let audio_cache = self.init_audio_cache(
-            &config.get_audio_cache_dir()?,
-            config.get_audio_cache_size()?
-        ).await?;
+        let audio_cache = self
+            .init_audio_cache(
+                &config.get_audio_cache_dir()?,
+                config.get_audio_cache_size()?,
+            )
+            .await?;
 
         Ok((cover_cache, audio_cache))
     }
@@ -425,9 +457,7 @@ impl UpnpServerExt for Server {
                 let kind = e.kind();
                 if kind == std::io::ErrorKind::AddrInUse {
                     let port = crate::ssdp::SSDP_PORT;
-                    if let Some(process) =
-                        find_process_using_port(port, TransportProtocol::Udp)
-                    {
+                    if let Some(process) = find_process_using_port(port, TransportProtocol::Udp) {
                         error!(
                             "❌ SSDP initialization failed: port {} is already in use by \
                             PID {} ({}) owned by {}: {}",
diff --git a/pmoupnp/src/variable_types/reflect_impl.rs b/pmoupnp/src/variable_types/reflect_impl.rs
index b29d77bd..241ae58b 100644
--- a/pmoupnp/src/variable_types/reflect_impl.rs
+++ b/pmoupnp/src/variable_types/reflect_impl.rs
@@ -4,8 +4,8 @@
 // (comme Uuid, Url, et certains types chrono), nous fournissons des méthodes de conversion
 // vers des types primitifs qui supportent Reflect.
 
-use bevy_reflect::Reflect;
 use crate::variable_types::{StateValue, StateValueError, StateVarType};
+use bevy_reflect::Reflect;
 
 impl StateValue {
     /// Convertit la StateValue en une valeur Reflect.
@@ -47,79 +47,88 @@ impl StateValue {
     /// Méthode statique utilisée pour reconstruire StateValue depuis Reflect
     pub fn from_reflect(
         value: &dyn Reflect,
-        expected_type: StateVarType
+        expected_type: StateVarType,
     ) -> Result<StateValue, StateValueError> {
         match expected_type {
-            StateVarType::UI1 => {
-                value.as_any().downcast_ref::<u8>()
-                    .map(|v| StateValue::UI1(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected u8".into()))
-            },
-            StateVarType::UI2 => {
-                value.as_any().downcast_ref::<u16>()
-                    .map(|v| StateValue::UI2(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected u16".into()))
-            },
-            StateVarType::UI4 => {
-                value.as_any().downcast_ref::<u32>()
-                    .map(|v| StateValue::UI4(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected u32".into()))
-            },
-            StateVarType::I1 => {
-                value.as_any().downcast_ref::<i8>()
-                    .map(|v| StateValue::I1(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected i8".into()))
-            },
-            StateVarType::I2 => {
-                value.as_any().downcast_ref::<i16>()
-                    .map(|v| StateValue::I2(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected i16".into()))
-            },
-            StateVarType::I4 | StateVarType::Int => {
-                value.as_any().downcast_ref::<i32>()
-                    .map(|v| StateValue::I4(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected i32".into()))
-            },
-            StateVarType::R4 => {
-                value.as_any().downcast_ref::<f32>()
-                    .map(|v| StateValue::R4(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected f32".into()))
-            },
-            StateVarType::R8 | StateVarType::Number | StateVarType::Fixed14_4 => {
-                value.as_any().downcast_ref::<f64>()
-                    .map(|v| StateValue::R8(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected f64".into()))
-            },
-            StateVarType::String | StateVarType::BinBase64 | StateVarType::BinHex => {
-                value.as_any().downcast_ref::<String>()
-                    .map(|v| match expected_type {
-                        StateVarType::String => StateValue::String(v.clone()),
-                        StateVarType::BinBase64 => StateValue::BinBase64(v.clone()),
-                        StateVarType::BinHex => StateValue::BinHex(v.clone()),
-                        _ => unreachable!(),
-                    })
-                    .ok_or_else(|| StateValueError::TypeError("Expected String".into()))
-            },
-            StateVarType::Boolean => {
-                value.as_any().downcast_ref::<bool>()
-                    .map(|v| StateValue::Boolean(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected bool".into()))
-            },
-            StateVarType::Char => {
-                value.as_any().downcast_ref::<char>()
-                    .map(|v| StateValue::Char(*v))
-                    .ok_or_else(|| StateValueError::TypeError("Expected char".into()))
-            },
+            StateVarType::UI1 => value
+                .as_any()
+                .downcast_ref::<u8>()
+                .map(|v| StateValue::UI1(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected u8".into())),
+            StateVarType::UI2 => value
+                .as_any()
+                .downcast_ref::<u16>()
+                .map(|v| StateValue::UI2(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected u16".into())),
+            StateVarType::UI4 => value
+                .as_any()
+                .downcast_ref::<u32>()
+                .map(|v| StateValue::UI4(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected u32".into())),
+            StateVarType::I1 => value
+                .as_any()
+                .downcast_ref::<i8>()
+                .map(|v| StateValue::I1(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected i8".into())),
+            StateVarType::I2 => value
+                .as_any()
+                .downcast_ref::<i16>()
+                .map(|v| StateValue::I2(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected i16".into())),
+            StateVarType::I4 | StateVarType::Int => value
+                .as_any()
+                .downcast_ref::<i32>()
+                .map(|v| StateValue::I4(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected i32".into())),
+            StateVarType::R4 => value
+                .as_any()
+                .downcast_ref::<f32>()
+                .map(|v| StateValue::R4(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected f32".into())),
+            StateVarType::R8 | StateVarType::Number | StateVarType::Fixed14_4 => value
+                .as_any()
+                .downcast_ref::<f64>()
+                .map(|v| StateValue::R8(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected f64".into())),
+            StateVarType::String | StateVarType::BinBase64 | StateVarType::BinHex => value
+                .as_any()
+                .downcast_ref::<String>()
+                .map(|v| match expected_type {
+                    StateVarType::String => StateValue::String(v.clone()),
+                    StateVarType::BinBase64 => StateValue::BinBase64(v.clone()),
+                    StateVarType::BinHex => StateValue::BinHex(v.clone()),
+                    _ => unreachable!(),
+                })
+                .ok_or_else(|| StateValueError::TypeError("Expected String".into())),
+            StateVarType::Boolean => value
+                .as_any()
+                .downcast_ref::<bool>()
+                .map(|v| StateValue::Boolean(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected bool".into())),
+            StateVarType::Char => value
+                .as_any()
+                .downcast_ref::<char>()
+                .map(|v| StateValue::Char(*v))
+                .ok_or_else(|| StateValueError::TypeError("Expected char".into())),
             // Pour les types complexes, on essaie de reconstruire depuis String
-            StateVarType::Date | StateVarType::DateTime | StateVarType::DateTimeTZ |
-            StateVarType::Time | StateVarType::TimeTZ | StateVarType::UUID | StateVarType::URI => {
-                value.as_any().downcast_ref::<String>()
-                    .ok_or_else(|| StateValueError::TypeError("Expected String representation".into()))
+            StateVarType::Date
+            | StateVarType::DateTime
+            | StateVarType::DateTimeTZ
+            | StateVarType::Time
+            | StateVarType::TimeTZ
+            | StateVarType::UUID
+            | StateVarType::URI => {
+                value
+                    .as_any()
+                    .downcast_ref::<String>()
+                    .ok_or_else(|| {
+                        StateValueError::TypeError("Expected String representation".into())
+                    })
                     .and_then(|s| {
                         // Utiliser les méthodes from_string existantes
                         StateValue::from_string(s, &expected_type)
                     })
-            },
+            }
         }
     }
 }
diff --git a/pmoupnp/src/variable_types/value_methods.rs b/pmoupnp/src/variable_types/value_methods.rs
index c4bbec51..abdf2c9a 100644
--- a/pmoupnp/src/variable_types/value_methods.rs
+++ b/pmoupnp/src/variable_types/value_methods.rs
@@ -116,41 +116,53 @@ impl StateValue {
         use uuid::Uuid;
 
         match var_type {
-            StateVarType::UI1 => s.parse::<u8>()
+            StateVarType::UI1 => s
+                .parse::<u8>()
                 .map(StateValue::UI1)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse UI1: {}", e))),
-            StateVarType::UI2 => s.parse::<u16>()
+            StateVarType::UI2 => s
+                .parse::<u16>()
                 .map(StateValue::UI2)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse UI2: {}", e))),
-            StateVarType::UI4 => s.parse::<u32>()
+            StateVarType::UI4 => s
+                .parse::<u32>()
                 .map(StateValue::UI4)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse UI4: {}", e))),
-            StateVarType::I1 => s.parse::<i8>()
+            StateVarType::I1 => s
+                .parse::<i8>()
                 .map(StateValue::I1)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse I1: {}", e))),
-            StateVarType::I2 => s.parse::<i16>()
+            StateVarType::I2 => s
+                .parse::<i16>()
                 .map(StateValue::I2)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse I2: {}", e))),
-            StateVarType::I4 | StateVarType::Int => s.parse::<i32>()
+            StateVarType::I4 | StateVarType::Int => s
+                .parse::<i32>()
                 .map(StateValue::I4)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse I4/Int: {}", e))),
-            StateVarType::R4 => s.parse::<f32>()
+            StateVarType::R4 => s
+                .parse::<f32>()
                 .map(StateValue::R4)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse R4: {}", e))),
-            StateVarType::R8 | StateVarType::Number | StateVarType::Fixed14_4 => s.parse::<f64>()
-                .map(StateValue::R8)
-                .map_err(|e| StateValueError::ParseError(format!("Failed to parse R8/Number: {}", e))),
-            StateVarType::Char => s.chars().next()
+            StateVarType::R8 | StateVarType::Number | StateVarType::Fixed14_4 => {
+                s.parse::<f64>().map(StateValue::R8).map_err(|e| {
+                    StateValueError::ParseError(format!("Failed to parse R8/Number: {}", e))
+                })
+            }
+            StateVarType::Char => s
+                .chars()
+                .next()
                 .ok_or_else(|| StateValueError::ParseError("Empty string for Char".to_string()))
                 .map(StateValue::Char),
             StateVarType::String => Ok(StateValue::String(s.to_string())),
-            StateVarType::Boolean => {
-                match s.to_lowercase().as_str() {
-                    "true" | "1" | "yes" => Ok(StateValue::Boolean(true)),
-                    "false" | "0" | "no" => Ok(StateValue::Boolean(false)),
-                    _ => Err(StateValueError::ParseError(format!("Invalid boolean value: {}", s))),
-                }
-            }
+            StateVarType::Boolean => match s.to_lowercase().as_str() {
+                "true" | "1" | "yes" => Ok(StateValue::Boolean(true)),
+                "false" | "0" | "no" => Ok(StateValue::Boolean(false)),
+                _ => Err(StateValueError::ParseError(format!(
+                    "Invalid boolean value: {}",
+                    s
+                ))),
+            },
             StateVarType::BinBase64 => Ok(StateValue::BinBase64(s.to_string())),
             StateVarType::BinHex => Ok(StateValue::BinHex(s.to_string())),
             StateVarType::Date => NaiveDate::parse_from_str(s, "%Y-%m-%d")
@@ -159,16 +171,24 @@ impl StateValue {
             StateVarType::DateTime => chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S")
                 .or_else(|_| chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S"))
                 .map(StateValue::DateTime)
-                .map_err(|e| StateValueError::ParseError(format!("Failed to parse DateTime: {}", e))),
+                .map_err(|e| {
+                    StateValueError::ParseError(format!("Failed to parse DateTime: {}", e))
+                }),
             StateVarType::DateTimeTZ => chrono::DateTime::parse_from_rfc3339(s)
                 .map(|dt| StateValue::DateTimeTZ(dt.into()))
-                .map_err(|e| StateValueError::ParseError(format!("Failed to parse DateTimeTZ: {}", e))),
+                .map_err(|e| {
+                    StateValueError::ParseError(format!("Failed to parse DateTimeTZ: {}", e))
+                }),
             StateVarType::Time => chrono::NaiveTime::parse_from_str(s, "%H:%M:%S")
                 .map(StateValue::Time)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse Time: {}", e))),
-            StateVarType::TimeTZ => chrono::DateTime::parse_from_rfc3339(&format!("1970-01-01T{}", s))
-                .map(|dt| StateValue::TimeTZ(dt.into()))
-                .map_err(|e| StateValueError::ParseError(format!("Failed to parse TimeTZ: {}", e))),
+            StateVarType::TimeTZ => {
+                chrono::DateTime::parse_from_rfc3339(&format!("1970-01-01T{}", s))
+                    .map(|dt| StateValue::TimeTZ(dt.into()))
+                    .map_err(|e| {
+                        StateValueError::ParseError(format!("Failed to parse TimeTZ: {}", e))
+                    })
+            }
             StateVarType::UUID => Uuid::parse_str(s)
                 .map(StateValue::UUID)
                 .map_err(|e| StateValueError::ParseError(format!("Failed to parse UUID: {}", e))),
diff --git a/pmoupnp/src/variable_types/values_from_str.rs b/pmoupnp/src/variable_types/values_from_str.rs
index 1054f650..16c0b832 100644
--- a/pmoupnp/src/variable_types/values_from_str.rs
+++ b/pmoupnp/src/variable_types/values_from_str.rs
@@ -17,4 +17,4 @@ impl TryFrom<String> for StateValue {
     fn try_from(s: String) -> Result<Self, StateValueError> {
         Ok(StateValue::String(s))
     }
-}
\ No newline at end of file
+}
diff --git a/pmoutils/src/ip_utils.rs b/pmoutils/src/ip_utils.rs
index 5328c9b1..c8ab423f 100644
--- a/pmoutils/src/ip_utils.rs
+++ b/pmoutils/src/ip_utils.rs
@@ -114,22 +114,25 @@ mod tests {
     #[test]
     fn test_guess_local_ip_returns_valid_ip() {
         let ip = guess_local_ip();
-        
+
         // Vérifie que le résultat est parsable comme une IP
-        assert!(ip.parse::<IpAddr>().is_ok(), "Should return a valid IP address");
+        assert!(
+            ip.parse::<IpAddr>().is_ok(),
+            "Should return a valid IP address"
+        );
     }
 
     #[test]
     fn test_guess_local_ip_not_empty() {
         let ip = guess_local_ip();
-        
+
         assert!(!ip.is_empty(), "IP should not be empty");
     }
 
     #[test]
     fn test_guess_local_ip_is_ipv4() {
         let ip = guess_local_ip();
-        
+
         if let Ok(parsed_ip) = ip.parse::<IpAddr>() {
             assert!(parsed_ip.is_ipv4(), "Should return an IPv4 address");
         }
@@ -141,7 +144,7 @@ mod tests {
         // (difficile à tester sans mocker, mais on vérifie la cohérence)
         let ip = guess_local_ip();
         let parsed = ip.parse::<IpAddr>().unwrap();
-        
+
         // L'IP doit être soit locale (127.0.0.1) soit une IP privée valide
         assert!(
             parsed.is_loopback() || is_private_ip(&ip),
@@ -152,7 +155,7 @@ mod tests {
     #[test]
     fn test_list_all_ips_no_loopback() {
         let ips = list_all_ips();
-        
+
         // Vérifie qu'aucune adresse de loopback n'est présente
         for (_, addresses) in ips.iter() {
             for addr in addresses {
@@ -169,13 +172,13 @@ mod tests {
     #[test]
     fn test_list_all_ips_only_ipv4() {
         let ips = list_all_ips();
-        
+
         // Vérifie que seules des adresses IPv4 sont retournées
         for (iface_name, addresses) in ips.iter() {
             if iface_name == "error" {
                 continue; // Skip error entries
             }
-            
+
             for addr in addresses {
                 if let Ok(parsed_ip) = addr.parse::<IpAddr>() {
                     assert!(
@@ -190,13 +193,13 @@ mod tests {
     #[test]
     fn test_list_all_ips_valid_format() {
         let ips = list_all_ips();
-        
+
         // Vérifie que toutes les IPs sont dans un format valide
         for (iface_name, addresses) in ips.iter() {
             if iface_name == "error" {
                 continue;
             }
-            
+
             for addr in addresses {
                 assert!(
                     addr.parse::<IpAddr>().is_ok(),
@@ -210,23 +213,26 @@ mod tests {
     #[test]
     fn test_list_all_ips_interface_names_not_empty() {
         let ips = list_all_ips();
-        
+
         // Vérifie que les noms d'interface ne sont pas vides
         for (iface_name, _) in ips.iter() {
-            assert!(!iface_name.is_empty(), "Interface names should not be empty");
+            assert!(
+                !iface_name.is_empty(),
+                "Interface names should not be empty"
+            );
         }
     }
 
     #[test]
     fn test_list_all_ips_no_duplicate_ips_per_interface() {
         let ips = list_all_ips();
-        
+
         // Vérifie qu'il n'y a pas de doublons par interface
         for (iface_name, addresses) in ips.iter() {
             if iface_name == "error" {
                 continue;
             }
-            
+
             let unique_addresses: std::collections::HashSet<_> = addresses.iter().collect();
             assert_eq!(
                 addresses.len(),
@@ -264,4 +270,4 @@ mod tests {
         assert!(!is_private_ip("8.8.8.8"));
         assert!(!is_private_ip("127.0.0.1")); // loopback n'est pas "privé" au sens réseau local
     }
-}
\ No newline at end of file
+}
diff --git a/pmoutils/src/lib.rs b/pmoutils/src/lib.rs
index ba1b25f5..8169a51a 100644
--- a/pmoutils/src/lib.rs
+++ b/pmoutils/src/lib.rs
@@ -19,7 +19,7 @@ pub mod ip_utils;
 
 pub use ip_utils::guess_local_ip;
 pub mod process;
-pub use process::{find_process_using_port, ProcessPortInfo, TransportProtocol};
+pub use process::{ProcessPortInfo, TransportProtocol, find_process_using_port};
 
 /// Retourne une chaîne décrivant le système d'exploitation et sa version.
 ///
diff --git a/pmoutils/src/process.rs b/pmoutils/src/process.rs
index c9569f49..37b46f75 100644
--- a/pmoutils/src/process.rs
+++ b/pmoutils/src/process.rs
@@ -1,4 +1,4 @@
-use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo};
+use netstat2::{AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, get_sockets_info};
 use sysinfo::{Pid, System};
 
 /// Informations sur un processus utilisant un port réseau.
@@ -39,8 +39,7 @@ pub fn find_process_using_port(port: u16, protocol: TransportProtocol) -> Option
     for socket in sockets {
         match socket.protocol_socket_info {
             ProtocolSocketInfo::Tcp(ref tcp_info)
-                if matches!(protocol, TransportProtocol::Tcp)
-                    && tcp_info.local_port == port =>
+                if matches!(protocol, TransportProtocol::Tcp) && tcp_info.local_port == port =>
             {
                 if let Some(info) =
                     build_process_info(&mut system, port, socket.associated_pids.first())
@@ -49,8 +48,7 @@ pub fn find_process_using_port(port: u16, protocol: TransportProtocol) -> Option
                 }
             }
             ProtocolSocketInfo::Udp(ref udp_info)
-                if matches!(protocol, TransportProtocol::Udp)
-                    && udp_info.local_port == port =>
+                if matches!(protocol, TransportProtocol::Udp) && udp_info.local_port == port =>
             {
                 if let Some(info) =
                     build_process_info(&mut system, port, socket.associated_pids.first())
@@ -77,8 +75,7 @@ fn build_process_info(
     let owner = process
         .user_id()
         .and_then(|uid| {
-            users::get_user_by_uid(**uid)
-                .map(|user| user.name().to_string_lossy().into_owned())
+            users::get_user_by_uid(**uid).map(|user| user.name().to_string_lossy().into_owned())
         })
         .unwrap_or_else(|| "unknown".to_string());