add SPA config UI, wire media/rss adapters, event-driven layout push

- React SPA: dashboard, data sources CRUD, widgets CRUD, layout builder,
  presets. TanStack Router + Query, shadcn/ui, Vite proxy to :3000
- wire media + rss adapters into polling loop, remove xtb source type
- media adapter: read username/password from headers, proper subsonic auth
- event handler: subscribe to LayoutChanged, push screen update to clients
- fix clippy warnings across workspace (Default impls, collapsible ifs,
  redundant closures, is_none_or, unused imports)

crates/application/src/config_service.rs

@@ -1,10 +1,8 @@
-use std::fmt;
 use domain::{
-    ConfigRepository, EventPublisher, DomainEvent,
-    WidgetConfig, WidgetId,
-    DataSource, DataSourceId, DataSourceValidationError,
-    Layout, LayoutPreset, LayoutPresetId,
+    ConfigRepository, DataSource, DataSourceId, DataSourceValidationError, DomainEvent,
+    EventPublisher, Layout, LayoutPreset, LayoutPresetId, WidgetConfig, WidgetId,
 };
+use std::fmt;
 
 pub struct ConfigService<'a, C, E> {
     config: &'a C,
@@ -34,78 +32,173 @@ where
         Self { config, events }
     }
 
-    pub async fn create_widget(&self, widget: WidgetConfig) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.save_widget(&widget).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::WidgetCreated { id: widget.id }).await.map_err(ConfigError::Event)?;
+    pub async fn create_widget(
+        &self,
+        widget: WidgetConfig,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        self.config
+            .save_widget(&widget)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::WidgetCreated { id: widget.id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn update_widget(&self, widget: WidgetConfig) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.save_widget(&widget).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::WidgetUpdated { id: widget.id }).await.map_err(ConfigError::Event)?;
+    pub async fn update_widget(
+        &self,
+        widget: WidgetConfig,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        self.config
+            .save_widget(&widget)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::WidgetUpdated { id: widget.id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
     pub async fn delete_widget(&self, id: WidgetId) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.delete_widget(id).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::WidgetDeleted { id }).await.map_err(ConfigError::Event)?;
+        self.config
+            .delete_widget(id)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::WidgetDeleted { id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn create_data_source(&self, source: DataSource) -> Result<(), ConfigError<C::Error, E::Error>> {
+    pub async fn create_data_source(
+        &self,
+        source: DataSource,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
         let errors = source.validate();
         if !errors.is_empty() {
             return Err(ConfigError::Validation(errors));
         }
-        self.config.save_data_source(&source).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::DataSourceAdded { id: source.id }).await.map_err(ConfigError::Event)?;
+        self.config
+            .save_data_source(&source)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::DataSourceAdded { id: source.id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn update_data_source(&self, source: DataSource) -> Result<(), ConfigError<C::Error, E::Error>> {
+    pub async fn update_data_source(
+        &self,
+        source: DataSource,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
         let errors = source.validate();
         if !errors.is_empty() {
             return Err(ConfigError::Validation(errors));
         }
-        self.config.save_data_source(&source).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::DataSourceUpdated { id: source.id }).await.map_err(ConfigError::Event)?;
+        self.config
+            .save_data_source(&source)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::DataSourceUpdated { id: source.id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn delete_data_source(&self, id: DataSourceId) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.delete_data_source(id).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::DataSourceRemoved { id }).await.map_err(ConfigError::Event)?;
+    pub async fn delete_data_source(
+        &self,
+        id: DataSourceId,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        self.config
+            .delete_data_source(id)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::DataSourceRemoved { id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn update_layout(&self, layout: Layout) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.save_layout(&layout).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::LayoutChanged { layout }).await.map_err(ConfigError::Event)?;
+    pub async fn update_layout(
+        &self,
+        layout: Layout,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        self.config
+            .save_layout(&layout)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::LayoutChanged { layout })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn save_preset(&self, preset: LayoutPreset) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.save_preset(&preset).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::LayoutPresetSaved { id: preset.id }).await.map_err(ConfigError::Event)?;
+    pub async fn save_preset(
+        &self,
+        preset: LayoutPreset,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        self.config
+            .save_preset(&preset)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::LayoutPresetSaved { id: preset.id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 
-    pub async fn load_preset(&self, id: LayoutPresetId) -> Result<(), ConfigError<C::Error, E::Error>> {
-        let preset = self.config.get_preset(id).await
+    pub async fn load_preset(
+        &self,
+        id: LayoutPresetId,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        let preset = self
+            .config
+            .get_preset(id)
+            .await
             .map_err(ConfigError::Repository)?
             .ok_or(ConfigError::NotFound)?;
 
-        self.events.publish(DomainEvent::LayoutPresetLoaded { id }).await.map_err(ConfigError::Event)?;
+        self.events
+            .publish(DomainEvent::LayoutPresetLoaded { id })
+            .await
+            .map_err(ConfigError::Event)?;
 
-        self.config.save_layout(&preset.layout).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::LayoutChanged { layout: preset.layout }).await.map_err(ConfigError::Event)?;
+        self.config
+            .save_layout(&preset.layout)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::LayoutChanged {
+                layout: preset.layout,
+            })
+            .await
+            .map_err(ConfigError::Event)?;
 
         Ok(())
     }
 
-    pub async fn delete_preset(&self, id: LayoutPresetId) -> Result<(), ConfigError<C::Error, E::Error>> {
-        self.config.delete_preset(id).await.map_err(ConfigError::Repository)?;
-        self.events.publish(DomainEvent::LayoutPresetDeleted { id }).await.map_err(ConfigError::Event)?;
+    pub async fn delete_preset(
+        &self,
+        id: LayoutPresetId,
+    ) -> Result<(), ConfigError<C::Error, E::Error>> {
+        self.config
+            .delete_preset(id)
+            .await
+            .map_err(ConfigError::Repository)?;
+        self.events
+            .publish(DomainEvent::LayoutPresetDeleted { id })
+            .await
+            .map_err(ConfigError::Event)?;
         Ok(())
     }
 }

crates/application/src/data_projection.rs

@@ -1,15 +1,18 @@
-use std::collections::HashMap;
 use domain::{DataSourceId, Value, WidgetConfig, WidgetId, WidgetState};
+use std::collections::HashMap;
 
+#[derive(Default)]
 pub struct DataProjection {
     current: HashMap<WidgetId, WidgetState>,
 }
 
 impl DataProjection {
     pub fn new() -> Self {
-        Self {
-            current: HashMap::new(),
-        }
+        Self::default()
+    }
+
+    pub fn get_state(&self, widget_id: WidgetId) -> Option<&WidgetState> {
+        self.current.get(&widget_id)
     }
 
     pub fn apply_poll_result(
@@ -27,9 +30,10 @@ impl DataProjection {
 
             let new_state = config.extract(raw);
 
-            let is_changed = self.current
+            let is_changed = self
+                .current
                 .get(&config.id)
-                .map_or(true, |prev| *prev != new_state);
+                .is_none_or(|prev| *prev != new_state);
 
             if is_changed {
                 self.current.insert(config.id, new_state.clone());