removed callback patterns

Cargo.lock

@@ -572,7 +572,7 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "fluxo-rs"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
  "anyhow",
  "bluer",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fluxo-rs"
-version = "0.4.3"
+version = "0.5.0"
 edition = "2024"
 
 [features]

src/daemon.rs

@@ -31,6 +31,64 @@ use tokio::time::{Duration, sleep};
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, info};
 
+/// Spawn a health-tracked polling loop. `$poll_expr` is awaited each cycle.
+macro_rules! spawn_poll_loop {
+    ($name:expr, $interval:expr, $health:expr, $token:expr, $poll_expr:expr) => {
+        tokio::spawn(async move {
+            info!(concat!("Starting ", $name, " polling task"));
+            loop {
+                if !crate::health::is_poll_in_backoff($name, &$health).await {
+                    let res: crate::error::Result<()> = $poll_expr.await;
+                    crate::health::handle_poll_result($name, res, &$health).await;
+                }
+                tokio::select! {
+                    _ = $token.cancelled() => break,
+                    _ = sleep($interval) => {}
+                }
+            }
+            info!(concat!($name, " task shut down."));
+        })
+    };
+}
+
+/// Spawn a health-tracked polling loop with an extra trigger channel for early wake-up.
+macro_rules! spawn_poll_loop_triggered {
+    ($name:expr, $interval:expr, $health:expr, $token:expr, $trigger:expr, $poll_expr:expr) => {
+        tokio::spawn(async move {
+            info!(concat!("Starting ", $name, " polling task"));
+            loop {
+                if !crate::health::is_poll_in_backoff($name, &$health).await {
+                    let res: crate::error::Result<()> = $poll_expr.await;
+                    crate::health::handle_poll_result($name, res, &$health).await;
+                }
+                tokio::select! {
+                    _ = $token.cancelled() => break,
+                    _ = $trigger.recv() => {},
+                    _ = sleep($interval) => {}
+                }
+            }
+            info!(concat!($name, " task shut down."));
+        })
+    };
+}
+
+/// Spawn a simple polling loop without health tracking.
+macro_rules! spawn_poll_loop_simple {
+    ($name:expr, $interval:expr, $token:expr, $poll_expr:expr) => {
+        tokio::spawn(async move {
+            info!(concat!("Starting ", $name, " polling task"));
+            loop {
+                $poll_expr.await;
+                tokio::select! {
+                    _ = $token.cancelled() => break,
+                    _ = sleep($interval) => {}
+                }
+            }
+            info!(concat!($name, " task shut down."));
+        })
+    };
+}
+
 struct SocketGuard {
     path: String,
 }
@@ -85,6 +143,8 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     let health = Arc::new(RwLock::new(HashMap::new()));
     #[cfg(feature = "mod-bt")]
     let (bt_force_tx, mut bt_force_rx) = mpsc::channel(1);
+    #[cfg(feature = "mod-bt")]
+    let bt_cycle = Arc::new(RwLock::new(0usize));
     #[cfg(feature = "mod-audio")]
     let (audio_cmd_tx, audio_cmd_rx) = mpsc::channel(8);
 
@@ -103,6 +163,8 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
         disks: disks_rx,
         #[cfg(feature = "mod-bt")]
         bluetooth: bt_rx,
+        #[cfg(feature = "mod-bt")]
+        bt_cycle,
         #[cfg(feature = "mod-audio")]
         audio: audio_rx,
         #[cfg(feature = "mod-dbus")]
@@ -140,75 +202,21 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
 
     let resolved_config_path = get_config_path(config_path.clone());
     let config = Arc::new(RwLock::new(crate::config::load_config(config_path.clone())));
-
-    // 0. Config Watcher (Hot Reload)
-    let watcher_config = Arc::clone(&config);
-    let watcher_path = resolved_config_path.clone();
-    tokio::spawn(async move {
-        let (ev_tx, mut ev_rx) = mpsc::channel(1);
-        let mut watcher = RecommendedWatcher::new(
-            move |res: notify::Result<Event>| {
-                if let Ok(event) = res
-                    && (event.kind.is_modify() || event.kind.is_create())
-                {
-                    let _ = ev_tx.blocking_send(());
-                }
-            },
-            NotifyConfig::default(),
-        )
-        .unwrap();
-
-        if let Some(parent) = watcher_path.parent() {
-            let _ = watcher.watch(parent, RecursiveMode::NonRecursive);
-        }
-
-        info!("Config watcher started on {:?}", watcher_path);
-
-        loop {
-            tokio::select! {
-                _ = ev_rx.recv() => {
-                    // Debounce reloads
-                    sleep(Duration::from_millis(100)).await;
-                    while ev_rx.try_recv().is_ok() {}
-                    reload_config(&watcher_config, Some(watcher_path.clone())).await;
-                }
-            }
-        }
-    });
-
-    // 0.1 SIGHUP Handler
-    let hup_config = Arc::clone(&config);
-    let hup_path = resolved_config_path.clone();
-    tokio::spawn(async move {
-        use tokio::signal::unix::{SignalKind, signal};
-        let mut stream = signal(SignalKind::hangup()).unwrap();
-        loop {
-            stream.recv().await;
-            info!("Received SIGHUP, reloading config...");
-            reload_config(&hup_config, Some(hup_path.clone())).await;
-        }
-    });
+    spawn_config_watchers(&config, &resolved_config_path);
 
     // 1. Network Task
     #[cfg(feature = "mod-network")]
     if config.read().await.network.enabled {
-        let token = cancel_token.clone();
-        let net_health = Arc::clone(&health);
-        tokio::spawn(async move {
-            info!("Starting Network polling task");
         let mut daemon = NetworkDaemon::new();
-            loop {
-                if !crate::health::is_poll_in_backoff("net", &net_health).await {
-                    let res = daemon.poll(&net_tx).await;
-                    crate::health::handle_poll_result("net", res, &net_health).await;
-                }
-                tokio::select! {
-                    _ = token.cancelled() => break,
-                    _ = sleep(Duration::from_secs(1)) => {}
-                }
-            }
-            info!("Network task shut down.");
-        });
+        let token = cancel_token.clone();
+        let h = Arc::clone(&health);
+        spawn_poll_loop!(
+            "net",
+            Duration::from_secs(1),
+            h,
+            token,
+            daemon.poll(&net_tx)
+        );
     }
 
     // 2. Fast Hardware Task (CPU, Mem, Load)
@@ -218,22 +226,14 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
         let fast_enabled = cfg.cpu.enabled || cfg.memory.enabled || cfg.sys.enabled;
         drop(cfg);
         if fast_enabled {
-            let token = cancel_token.clone();
-            let hw_health = Arc::clone(&health);
-            tokio::spawn(async move {
-                info!("Starting Fast Hardware polling task");
             let mut daemon = HardwareDaemon::new();
-                loop {
-                    if !crate::health::is_poll_in_backoff("cpu", &hw_health).await {
-                        daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx).await;
-                    }
-                    tokio::select! {
-                        _ = token.cancelled() => break,
-                        _ = sleep(Duration::from_secs(1)) => {}
-                    }
-                }
-                info!("Fast Hardware task shut down.");
-            });
+            let token = cancel_token.clone();
+            spawn_poll_loop_simple!(
+                "fast_hw",
+                Duration::from_secs(1),
+                token,
+                daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx)
+            );
         }
     }
 
@@ -244,47 +244,29 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
         let slow_enabled = cfg.gpu.enabled || cfg.disk.enabled;
         drop(cfg);
         if slow_enabled {
-            let token = cancel_token.clone();
-            let slow_health = Arc::clone(&health);
-            tokio::spawn(async move {
-                info!("Starting Slow Hardware polling task");
             let mut daemon = HardwareDaemon::new();
-                loop {
-                    if !crate::health::is_poll_in_backoff("gpu", &slow_health).await {
-                        daemon.poll_slow(&gpu_tx, &disks_tx).await;
-                    }
-                    tokio::select! {
-                        _ = token.cancelled() => break,
-                        _ = sleep(Duration::from_secs(5)) => {}
-                    }
-                }
-                info!("Slow Hardware task shut down.");
-            });
+            let token = cancel_token.clone();
+            spawn_poll_loop_simple!(
+                "slow_hw",
+                Duration::from_secs(5),
+                token,
+                daemon.poll_slow(&gpu_tx, &disks_tx)
+            );
         }
     }
 
     // 4. Bluetooth Task
     #[cfg(feature = "mod-bt")]
     if config.read().await.bt.enabled {
+        let mut daemon = BtDaemon::new();
         let token = cancel_token.clone();
-        let bt_health = Arc::clone(&health);
+        let h = Arc::clone(&health);
         let poll_config = Arc::clone(&config);
         let poll_receivers = receivers.clone();
-        tokio::spawn(async move {
-            info!("Starting Bluetooth polling task");
-            let mut daemon = BtDaemon::new();
-            loop {
-                if !crate::health::is_poll_in_backoff("bt", &bt_health).await {
+        spawn_poll_loop_triggered!("bt", Duration::from_secs(2), h, token, bt_force_rx, async {
             let config = poll_config.read().await;
             daemon.poll(&bt_tx, &poll_receivers, &config).await;
-                }
-                tokio::select! {
-                    _ = token.cancelled() => break,
-                    _ = bt_force_rx.recv() => {},
-                    _ = sleep(Duration::from_secs(2)) => {}
-                }
-            }
-            info!("Bluetooth task shut down.");
+            Ok(())
         });
     }
 
@@ -347,12 +329,68 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     });
 
     info!("Fluxo daemon successfully bound to socket: {}", sock_path);
+    run_ipc_loop(listener, receivers, config, config_path, cancel_token).await
+}
+
+fn spawn_config_watchers(config: &Arc<RwLock<Config>>, resolved_path: &std::path::Path) {
+    // File watcher (hot reload on modify/create)
+    let watcher_config = Arc::clone(config);
+    let watcher_path = resolved_path.to_path_buf();
+    tokio::spawn(async move {
+        let (ev_tx, mut ev_rx) = mpsc::channel(1);
+        let mut watcher = RecommendedWatcher::new(
+            move |res: notify::Result<Event>| {
+                if let Ok(event) = res
+                    && (event.kind.is_modify() || event.kind.is_create())
+                {
+                    let _ = ev_tx.blocking_send(());
+                }
+            },
+            NotifyConfig::default(),
+        )
+        .unwrap();
+
+        if let Some(parent) = watcher_path.parent() {
+            let _ = watcher.watch(parent, RecursiveMode::NonRecursive);
+        }
+
+        info!("Config watcher started on {:?}", watcher_path);
 
         loop {
             tokio::select! {
-            _ = cancel_token.cancelled() => {
-                break;
+                _ = ev_rx.recv() => {
+                    sleep(Duration::from_millis(100)).await;
+                    while ev_rx.try_recv().is_ok() {}
+                    reload_config(&watcher_config, Some(watcher_path.clone())).await;
                 }
+            }
+        }
+    });
+
+    // SIGHUP handler
+    let hup_config = Arc::clone(config);
+    let hup_path = resolved_path.to_path_buf();
+    tokio::spawn(async move {
+        use tokio::signal::unix::{SignalKind, signal};
+        let mut stream = signal(SignalKind::hangup()).unwrap();
+        loop {
+            stream.recv().await;
+            info!("Received SIGHUP, reloading config...");
+            reload_config(&hup_config, Some(hup_path.clone())).await;
+        }
+    });
+}
+
+async fn run_ipc_loop(
+    listener: UnixListener,
+    receivers: AppReceivers,
+    config: Arc<RwLock<Config>>,
+    config_path: Option<PathBuf>,
+    cancel_token: CancellationToken,
+) -> Result<()> {
+    loop {
+        tokio::select! {
+            _ = cancel_token.cancelled() => break,
             res = listener.accept() => {
                 match res {
                     Ok((mut stream, _)) => {

src/macros.rs

@@ -0,0 +1,36 @@
+/// Central module registry. Defines all modules with watch channels in one place.
+///
+/// Invoke with a callback macro name. The callback receives repeated entries of the form:
+///   { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident }
+///
+/// Fields:
+///   - feature:       Cargo feature gate (e.g., "mod-network")
+///   - field:         AppReceivers field name (e.g., network)
+///   - state:         State type for the watch channel (e.g., NetworkState)
+///   - names:         CLI name aliases for dispatch (e.g., ["net", "network"])
+///   - signaler_names: Waybar module names to signal when the channel fires
+///     (usually [first dispatch name], but audio signals ["vol", "mic"])
+///   - module:        Module struct implementing WaybarModule (e.g., network::NetworkModule)
+///   - signal:        SignalsConfig field name (e.g., network)
+///   - default_args:  Default args for signaler evaluation
+///   - config:        Config section field name (e.g., network)
+///
+/// Modules without watch channels (power, game, pool/btrfs) are handled manually.
+macro_rules! for_each_watched_module {
+    ($m:ident) => {
+        $m! {
+            { "mod-network",  network,   crate::state::NetworkState,       ["net", "network"],  ["net"],        crate::modules::network::NetworkModule,     network,   [],               network   }
+            { "mod-hardware", cpu,       crate::state::CpuState,           ["cpu"],             ["cpu"],        crate::modules::cpu::CpuModule,             cpu,       [],               cpu       }
+            { "mod-hardware", memory,    crate::state::MemoryState,        ["mem", "memory"],   ["mem"],        crate::modules::memory::MemoryModule,       memory,    [],               memory    }
+            { "mod-hardware", sys,       crate::state::SysState,           ["sys"],             ["sys"],        crate::modules::sys::SysModule,             sys,       [],               sys       }
+            { "mod-hardware", gpu,       crate::state::GpuState,           ["gpu"],             ["gpu"],        crate::modules::gpu::GpuModule,             gpu,       [],               gpu       }
+            { "mod-hardware", disks,     Vec<crate::state::DiskInfo>,      ["disk"],            ["disk"],       crate::modules::disk::DiskModule,           disk,      ["/"],            disk      }
+            { "mod-bt",       bluetooth, crate::state::BtState,            ["bt", "bluetooth"], ["bt"],         crate::modules::bt::BtModule,               bt,        ["show"],         bt        }
+            { "mod-audio",    audio,     crate::state::AudioState,         ["vol", "audio"],    ["vol", "mic"], crate::modules::audio::AudioModule,         audio,     ["sink", "show"], audio     }
+            { "mod-dbus",     mpris,     crate::state::MprisState,         ["mpris"],           ["mpris"],      crate::modules::mpris::MprisModule,         mpris,     [],               mpris     }
+            { "mod-dbus",     backlight, crate::state::BacklightState,     ["backlight"],       ["backlight"],  crate::modules::backlight::BacklightModule, backlight, [],               backlight }
+            { "mod-dbus",     keyboard,  crate::state::KeyboardState,      ["kbd", "keyboard"], ["kbd"],        crate::modules::keyboard::KeyboardModule,   keyboard,  [],               keyboard  }
+            { "mod-dbus",     dnd,       crate::state::DndState,           ["dnd"],             ["dnd"],        crate::modules::dnd::DndModule,             dnd,       [],               dnd       }
+        }
+    };
+}

src/main.rs

@@ -1,3 +1,5 @@
+#[macro_use]
+mod macros;
 mod config;
 mod daemon;
 mod error;
@@ -83,30 +85,47 @@ fn main() {
             let config = config::load_config(None);
             let mut items = Vec::new();
 
-            if let Ok(json_str) = ipc::request_data("bt", &["get_modes"])
+            // Parse menu_data to get connected and paired devices
+            let mut connected: Vec<(String, String)> = Vec::new(); // (alias, mac)
+            let mut paired: Vec<(String, String)> = Vec::new();
+
+            if let Ok(json_str) = ipc::request_data("bt", &["menu_data"])
+                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
+                && let Some(text) = val.get("text").and_then(|t| t.as_str())
+            {
+                for line in text.lines() {
+                    if let Some(rest) = line.strip_prefix("CONNECTED:")
+                        && let Some((alias, mac)) = rest.split_once('|')
+                    {
+                        connected.push((alias.to_string(), mac.to_string()));
+                    } else if let Some(rest) = line.strip_prefix("PAIRED:")
+                        && let Some((alias, mac)) = rest.split_once('|')
+                    {
+                        paired.push((alias.to_string(), mac.to_string()));
+                    }
+                }
+            }
+
+            // Per-device sections for connected devices
+            for (alias, mac) in &connected {
+                // Get modes for this specific device
+                if let Ok(json_str) = ipc::request_data("bt", &["get_modes", mac])
                     && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
                     && let Some(modes_str) = val.get("text").and_then(|t| t.as_str())
                     && !modes_str.is_empty()
                 {
                     for mode in modes_str.lines() {
-                    items.push(format!("Mode: {}", mode));
+                        items.push(format!("{}: Mode: {} [{}]", alias, mode, mac));
                     }
                 }
+                items.push(format!("Disconnect {} [{}]", alias, mac));
+            }
 
-            if !items.is_empty() {
-                items.push("Disconnect".to_string());
-            }
-
+            // Separator and paired devices for connecting
+            if !paired.is_empty() {
                 items.push("--- Connect Device ---".to_string());
-
-            if let Ok(json_str) = ipc::request_data("bt", &["menu_data"])
-                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
-                && let Some(devices_str) = val.get("text").and_then(|t| t.as_str())
-            {
-                for line in devices_str.lines() {
-                    if !line.is_empty() {
-                        items.push(line.to_string());
-                    }
+                for (alias, mac) in &paired {
+                    items.push(format!("{} ({})", alias, mac));
                 }
             }
 
@@ -114,12 +133,31 @@ fn main() {
                 if let Ok(selected) =
                     utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
                 {
-                    if let Some(mode) = selected.strip_prefix("Mode: ") {
-                        handle_ipc_response(ipc::request_data("bt", &["set_mode", mode]));
-                    } else if selected == "Disconnect" {
-                        handle_ipc_response(ipc::request_data("bt", &["disconnect"]));
+                    if selected.contains(": Mode: ") {
+                        // "<alias>: Mode: <mode> [<MAC>]"
+                        if let Some(bracket_start) = selected.rfind('[')
+                            && let Some(bracket_end) = selected.rfind(']')
+                        {
+                            let mac = &selected[bracket_start + 1..bracket_end];
+                            if let Some(mode_start) = selected.find(": Mode: ") {
+                                let mode =
+                                    &selected[mode_start + ": Mode: ".len()..bracket_start - 1];
+                                handle_ipc_response(ipc::request_data(
+                                    "bt",
+                                    &["set_mode", mode, mac],
+                                ));
+                            }
+                        }
+                    } else if selected.starts_with("Disconnect ") {
+                        // "Disconnect <alias> [<MAC>]"
+                        if let Some(bracket_start) = selected.rfind('[')
+                            && let Some(bracket_end) = selected.rfind(']')
+                        {
+                            let mac = &selected[bracket_start + 1..bracket_end];
+                            handle_ipc_response(ipc::request_data("bt", &["disconnect", mac]));
+                        }
                     } else if selected == "--- Connect Device ---" {
-                        // Do nothing
+                        // separator, do nothing
                     } else if let Some(mac_start) = selected.rfind('(')
                         && let Some(mac_end) = selected.rfind(')')
                     {

src/modules/audio.rs

@@ -2,13 +2,14 @@ use crate::config::Config;
 use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::{AppReceivers, AudioState};
+use crate::state::{AppReceivers, AudioDeviceInfo, AudioState};
 use crate::utils::{TokenValue, format_template};
 use libpulse_binding::callbacks::ListResult;
 use libpulse_binding::context::subscribe::{Facility, InterestMaskSet};
 use libpulse_binding::context::{Context, FlagSet as ContextFlag};
 use libpulse_binding::mainloop::threaded::Mainloop as ThreadedMainloop;
 use libpulse_binding::volume::Volume;
+use std::sync::Arc;
 use tokio::sync::{mpsc, watch};
 use tracing::error;
 
@@ -229,92 +230,124 @@ fn fetch_audio_data_sync(
         let _ = tx_server.send(current);
     });
 
-    let tx_sink = state_tx.clone();
-    context.introspect().get_sink_info_list(move |res| {
-        let mut current = tx_sink.borrow().clone();
-        match res {
-            ListResult::Item(item) => {
-                if let Some(name) = item.name.as_ref() {
-                    let name_str = name.to_string();
-                    if !current.available_sinks.contains(&name_str) {
-                        current.available_sinks.push(name_str);
-                    }
-                }
-
-                let is_default = item
-                    .name
-                    .as_ref()
-                    .map(|s| s.as_ref() == current.sink.name)
-                    .unwrap_or(false);
-                if is_default {
-                    current.sink.description = item
-                        .description
-                        .as_ref()
-                        .map(|s| s.to_string())
-                        .unwrap_or_default();
-                    current.sink.volume = ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64)
-                        * 100.0)
-                        .round() as u8;
-                    current.sink.muted = item.mute;
-                    current.sink.channels = item.volume.len();
-                }
-                let _ = tx_sink.send(current);
-            }
-            ListResult::End => {
-                // Clear the list on End so it rebuilds fresh next time
-                current.available_sinks.clear();
-                let _ = tx_sink.send(current);
-            }
-            ListResult::Error => {}
-        }
-    });
-
-    let tx_source = state_tx.clone();
-    context.introspect().get_source_info_list(move |res| {
-        let mut current = tx_source.borrow().clone();
-        match res {
-            ListResult::Item(item) => {
-                if let Some(name) = item.name.as_ref() {
-                    let name_str = name.to_string();
-                    // PulseAudio includes monitor sources, ignore them if we want to
-                    if !name_str.contains(".monitor")
-                        && !current.available_sources.contains(&name_str)
-                    {
-                        current.available_sources.push(name_str);
-                    }
-                }
-
-                let is_default = item
-                    .name
-                    .as_ref()
-                    .map(|s| s.as_ref() == current.source.name)
-                    .unwrap_or(false);
-                if is_default {
-                    current.source.description = item
-                        .description
-                        .as_ref()
-                        .map(|s| s.to_string())
-                        .unwrap_or_default();
-                    current.source.volume = ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64)
-                        * 100.0)
-                        .round() as u8;
-                    current.source.muted = item.mute;
-                    current.source.channels = item.volume.len();
-                }
-                let _ = tx_source.send(current);
-            }
-            ListResult::End => {
-                // Clear the list on End so it rebuilds fresh next time
-                current.available_sources.clear();
-                let _ = tx_source.send(current);
-            }
-            ListResult::Error => {}
-        }
-    });
+    fetch_sinks(context, state_tx);
+    fetch_sources(context, state_tx);
 
     Ok(())
 }
 
+/// Shared bookkeeping for a device list fetch.
+struct PendingList {
+    names: Arc<std::sync::Mutex<Vec<String>>>,
+}
+
+impl PendingList {
+    fn new() -> Self {
+        Self {
+            names: Arc::new(std::sync::Mutex::new(Vec::new())),
+        }
+    }
+
+    fn push(&self, name: String) {
+        self.names.lock().unwrap().push(name);
+    }
+
+    fn drain(&self) -> Vec<String> {
+        self.names.lock().unwrap().drain(..).collect()
+    }
+}
+
+/// Extract common device info from a pulse item's volume/mute/description fields.
+fn device_info_from(
+    description: Option<&str>,
+    volume: &libpulse_binding::volume::ChannelVolumes,
+    muted: bool,
+) -> (String, u8, bool, u8) {
+    let desc = description.unwrap_or_default().to_string();
+    let vol = ((volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
+    let channels = volume.len();
+    (desc, vol, muted, channels)
+}
+
+fn apply_device_info(target: &mut AudioDeviceInfo, item_name: &str, info: (String, u8, bool, u8)) {
+    if item_name == target.name {
+        target.description = info.0;
+        target.volume = info.1;
+        target.muted = info.2;
+        target.channels = info.3;
+    }
+}
+
+fn fetch_sinks(context: &mut Context, state_tx: &watch::Sender<AudioState>) {
+    let tx = state_tx.clone();
+    let pending = PendingList::new();
+    let pending_cb = PendingList {
+        names: Arc::clone(&pending.names),
+    };
+    context.introspect().get_sink_info_list(move |res| {
+        let mut current = tx.borrow().clone();
+        match res {
+            ListResult::Item(item) => {
+                let name_str = item
+                    .name
+                    .as_ref()
+                    .map(|s| s.to_string())
+                    .unwrap_or_default();
+                if !name_str.is_empty() {
+                    pending_cb.push(name_str.clone());
+                }
+                let info = device_info_from(
+                    item.description.as_ref().map(|s| s.as_ref()),
+                    &item.volume,
+                    item.mute,
+                );
+                apply_device_info(&mut current.sink, &name_str, info);
+                let _ = tx.send(current);
+            }
+            ListResult::End => {
+                current.available_sinks = pending_cb.drain();
+                let _ = tx.send(current);
+            }
+            ListResult::Error => {}
+        }
+    });
+}
+
+fn fetch_sources(context: &mut Context, state_tx: &watch::Sender<AudioState>) {
+    let tx = state_tx.clone();
+    let pending = PendingList::new();
+    let pending_cb = PendingList {
+        names: Arc::clone(&pending.names),
+    };
+    context.introspect().get_source_info_list(move |res| {
+        let mut current = tx.borrow().clone();
+        match res {
+            ListResult::Item(item) => {
+                let name_str = item
+                    .name
+                    .as_ref()
+                    .map(|s| s.to_string())
+                    .unwrap_or_default();
+                if !name_str.is_empty() && !name_str.contains(".monitor") {
+                    pending_cb.push(name_str.clone());
+                }
+                let info = device_info_from(
+                    item.description.as_ref().map(|s| s.as_ref()),
+                    &item.volume,
+                    item.mute,
+                );
+                apply_device_info(&mut current.source, &name_str, info);
+                let _ = tx.send(current);
+            }
+            ListResult::End => {
+                current.available_sources = pending_cb.drain();
+                let _ = tx.send(current);
+            }
+            ListResult::Error => {}
+        }
+    });
+}
+
 pub struct AudioModule;
 
 impl WaybarModule for AudioModule {
@@ -331,19 +364,19 @@ impl WaybarModule for AudioModule {
         match *action {
             "up" => {
                 self.change_volume(state, target_type, step, true).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "down" => {
                 self.change_volume(state, target_type, step, false).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "mute" => {
                 self.toggle_mute(state, target_type).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "cycle" => {
                 self.cycle_device(state, target_type).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "show" => self.get_status(config, state, target_type).await,
             other => Err(FluxoError::Module {

src/modules/bt/mod.rs

@@ -5,7 +5,7 @@ use crate::config::Config;
 use crate::error::Result as FluxoResult;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::{AppReceivers, BtState};
+use crate::state::{AppReceivers, BtDeviceInfo, BtState};
 use crate::utils::{TokenValue, format_template};
 use anyhow::Result;
 use std::sync::LazyLock;
@@ -47,32 +47,35 @@ impl BtDaemon {
         let adapter = session.default_adapter().await?;
         let adapter_powered = adapter.is_powered().await.unwrap_or(false);
 
-        let mut bt_state = BtState {
-            adapter_powered,
-            ..Default::default()
-        };
+        let mut connected_devices = Vec::new();
 
         if adapter_powered {
-            let devices = adapter.device_addresses().await?;
-            for addr in devices {
+            let mut addresses = adapter.device_addresses().await?;
+            addresses.sort();
+            let audio_sink_uuid = bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
+
+            for addr in addresses {
                 let device = adapter.device(addr)?;
-                if device.is_connected().await.unwrap_or(false) {
+                if !device.is_connected().await.unwrap_or(false) {
+                    continue;
+                }
                 let uuids = device.uuids().await?.unwrap_or_default();
-                    let audio_sink_uuid =
-                        bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
-                    if uuids.contains(&audio_sink_uuid) {
-                        bt_state.connected = true;
-                        bt_state.device_address = addr.to_string();
-                        bt_state.device_alias =
-                            device.alias().await.unwrap_or_else(|_| addr.to_string());
-                        bt_state.battery_percentage =
-                            device.battery_percentage().await.unwrap_or(None);
+                if !uuids.contains(&audio_sink_uuid) {
+                    continue;
+                }
+
+                let mut dev_info = BtDeviceInfo {
+                    device_address: addr.to_string(),
+                    device_alias: device.alias().await.unwrap_or_else(|_| addr.to_string()),
+                    battery_percentage: device.battery_percentage().await.unwrap_or(None),
+                    plugin_data: vec![],
+                };
 
                 for p in PLUGINS.iter() {
-                            if p.can_handle(&bt_state.device_alias, &bt_state.device_address) {
-                                match p.get_data(config, state, &bt_state.device_address).await {
+                    if p.can_handle(&dev_info.device_alias, &dev_info.device_address) {
+                        match p.get_data(config, state, &dev_info.device_address).await {
                             Ok(data) => {
-                                        bt_state.plugin_data = data
+                                dev_info.plugin_data = data
                                     .into_iter()
                                     .map(|(k, v)| {
                                         let val_str = match v {
@@ -86,7 +89,7 @@ impl BtDaemon {
                             }
                             Err(e) => {
                                 warn!("Plugin {} failed for {}: {}", p.name(), addr, e);
-                                        bt_state
+                                dev_info
                                     .plugin_data
                                     .push(("plugin_error".to_string(), e.to_string()));
                             }
@@ -94,13 +97,14 @@ impl BtDaemon {
                         break;
                     }
                 }
-                        break;
-                    }
-                }
+                connected_devices.push(dev_info);
             }
         }
 
-        let _ = tx.send(bt_state);
+        let _ = tx.send(BtState {
+            adapter_powered,
+            devices: connected_devices,
+        });
 
         Ok(())
     }
@@ -111,8 +115,6 @@ static PLUGINS: LazyLock<Vec<Box<dyn BtPlugin>>> =
 
 fn trigger_robust_poll(state: AppReceivers) {
     tokio::spawn(async move {
-        // Poll immediately and then a few times over the next few seconds
-        // to catch slow state changes in bluez or plugins.
         for delay in [200, 500, 1000, 2000, 3000] {
             tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
             let _ = state.bt_force_poll.try_send(());
@@ -120,6 +122,26 @@ fn trigger_robust_poll(state: AppReceivers) {
     });
 }
 
+/// Resolve a target MAC: use explicit arg if given, otherwise fall back to the active device.
+async fn resolve_target_mac(
+    bt_state: &BtState,
+    state: &AppReceivers,
+    explicit_mac: Option<&str>,
+) -> Option<String> {
+    if let Some(mac) = explicit_mac {
+        return Some(mac.to_string());
+    }
+    let idx = *state.bt_cycle.read().await;
+    bt_state
+        .active_device(idx)
+        .map(|d| d.device_address.clone())
+}
+
+/// Find a device in the current state by MAC.
+fn find_device<'a>(bt_state: &'a BtState, mac: &str) -> Option<&'a BtDeviceInfo> {
+    bt_state.devices.iter().find(|d| d.device_address == mac)
+}
+
 pub struct BtModule;
 
 impl WaybarModule for BtModule {
@@ -129,12 +151,10 @@ impl WaybarModule for BtModule {
         state: &AppReceivers,
         args: &[&str],
     ) -> FluxoResult<WaybarOutput> {
-        let action = args.first().cloned().unwrap_or("show").to_string();
-        let args = args.iter().map(|s| s.to_string()).collect::<Vec<_>>();
-
+        let action = args.first().cloned().unwrap_or("show");
         let bt_state = state.bluetooth.borrow().clone();
 
-        match action.as_str() {
+        match action {
             "connect" => {
                 if let Some(mac) = args.get(1) {
                     if let Ok(session) = bluer::Session::new().await
@@ -148,77 +168,125 @@ impl WaybarModule for BtModule {
                 }
                 return Ok(WaybarOutput::default());
             }
-            "disconnect" if bt_state.connected => {
+            "disconnect" => {
+                let target_mac = resolve_target_mac(&bt_state, state, args.get(1).copied()).await;
+                if let Some(mac) = target_mac {
                     if let Ok(session) = bluer::Session::new().await
                         && let Ok(adapter) = session.default_adapter().await
-                    && let Ok(addr) = bt_state.device_address.parse::<bluer::Address>()
+                        && let Ok(addr) = mac.parse::<bluer::Address>()
                         && let Ok(device) = adapter.device(addr)
                     {
                         let _ = device.disconnect().await;
                     }
                     trigger_robust_poll(state.clone());
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "cycle" => {
+                let count = bt_state.devices.len();
+                if count > 1 {
+                    let mut idx = state.bt_cycle.write().await;
+                    *idx = (*idx + 1) % count;
+                }
+                let _ = state.bt_force_poll.try_send(());
                 return Ok(WaybarOutput::default());
             }
             "menu_data" => {
-                let mut devs = Vec::new();
+                let mut lines = Vec::new();
+
+                // Connected devices
+                for dev in &bt_state.devices {
+                    lines.push(format!(
+                        "CONNECTED:{}|{}",
+                        dev.device_alias, dev.device_address
+                    ));
+                }
+
+                // Paired-but-not-connected devices
                 if let Ok(session) = bluer::Session::new().await
                     && let Ok(adapter) = session.default_adapter().await
                     && let Ok(addresses) = adapter.device_addresses().await
                 {
+                    let connected_macs: std::collections::HashSet<&str> = bt_state
+                        .devices
+                        .iter()
+                        .map(|d| d.device_address.as_str())
+                        .collect();
+
                     for addr in addresses {
+                        let addr_str = addr.to_string();
+                        if connected_macs.contains(addr_str.as_str()) {
+                            continue;
+                        }
                         if let Ok(device) = adapter.device(addr)
                             && device.is_paired().await.unwrap_or(false)
                         {
                             let alias = device.alias().await.unwrap_or_else(|_| addr.to_string());
-                            devs.push(format!("{} ({})", alias, addr));
+                            lines.push(format!("PAIRED:{}|{}", alias, addr_str));
                         }
                     }
                 }
+
                 return Ok(WaybarOutput {
-                    text: devs.join("\n"),
+                    text: lines.join("\n"),
                     ..Default::default()
                 });
             }
-            "cycle_mode" if bt_state.connected => {
+            "get_modes" => {
+                let target_mac = resolve_target_mac(&bt_state, state, args.get(1).copied()).await;
+                if let Some(mac) = target_mac
+                    && let Some(dev) = find_device(&bt_state, &mac)
+                {
                     let plugin = PLUGINS
                         .iter()
-                    .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
+                        .find(|p| p.can_handle(&dev.device_alias, &dev.device_address));
                     if let Some(p) = plugin {
-                    p.cycle_mode(&bt_state.device_address, state).await?;
-                    trigger_robust_poll(state.clone());
-                }
-                return Ok(WaybarOutput::default());
-            }
-            "get_modes" if bt_state.connected => {
-                let plugin = PLUGINS
-                    .iter()
-                    .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
-                let modes = if let Some(p) = plugin {
-                    p.get_modes(&bt_state.device_address, state).await?
-                } else {
-                    vec![]
-                };
+                        let modes = p.get_modes(&mac, state).await?;
                         return Ok(WaybarOutput {
                             text: modes.join("\n"),
                             ..Default::default()
                         });
                     }
-            "set_mode" if bt_state.connected => {
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "set_mode" => {
                 if let Some(mode) = args.get(1) {
+                    let target_mac =
+                        resolve_target_mac(&bt_state, state, args.get(2).copied()).await;
+                    if let Some(mac) = target_mac
+                        && let Some(dev) = find_device(&bt_state, &mac)
+                    {
                         let plugin = PLUGINS
                             .iter()
-                        .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
+                            .find(|p| p.can_handle(&dev.device_alias, &dev.device_address));
                         if let Some(p) = plugin {
-                        p.set_mode(mode, &bt_state.device_address, state).await?;
+                            p.set_mode(mode, &mac, state).await?;
+                            trigger_robust_poll(state.clone());
+                        }
+                    }
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "cycle_mode" => {
+                let target_mac = resolve_target_mac(&bt_state, state, args.get(1).copied()).await;
+                if let Some(mac) = target_mac
+                    && let Some(dev) = find_device(&bt_state, &mac)
+                {
+                    let plugin = PLUGINS
+                        .iter()
+                        .find(|p| p.can_handle(&dev.device_alias, &dev.device_address));
+                    if let Some(p) = plugin {
+                        p.cycle_mode(&mac, state).await?;
                         trigger_robust_poll(state.clone());
                     }
                 }
                 return Ok(WaybarOutput::default());
             }
-            "show" => {}
             _ => {}
         }
 
+        // "show" and fallthrough
         if !bt_state.adapter_powered {
             return Ok(WaybarOutput {
                 text: config.bt.format_disabled.clone(),
@@ -228,22 +296,23 @@ impl WaybarModule for BtModule {
             });
         }
 
-        if bt_state.connected {
+        let cycle_idx = *state.bt_cycle.read().await;
+        if let Some(dev) = bt_state.active_device(cycle_idx) {
             let mut tokens: Vec<(String, TokenValue)> = vec![
                 (
                     "alias".to_string(),
-                    TokenValue::String(bt_state.device_alias.clone()),
+                    TokenValue::String(dev.device_alias.clone()),
                 ),
                 (
                     "mac".to_string(),
-                    TokenValue::String(bt_state.device_address.clone()),
+                    TokenValue::String(dev.device_address.clone()),
                 ),
             ];
 
             let mut class = vec!["connected".to_string()];
             let mut has_plugin = false;
 
-            for (k, v) in &bt_state.plugin_data {
+            for (k, v) in &dev.plugin_data {
                 if k == "plugin_class" {
                     class.push(v.clone());
                     has_plugin = true;
@@ -263,10 +332,9 @@ impl WaybarModule for BtModule {
             let text = format_template(format, &tokens);
             let tooltip = format!(
                 "{} | MAC: {}\nBattery: {}",
-                bt_state.device_alias,
-                bt_state.device_address,
-                bt_state
-                    .battery_percentage
+                dev.device_alias,
+                dev.device_address,
+                dev.battery_percentage
                     .map(|b| format!("{}%", b))
                     .unwrap_or_else(|| "N/A".to_string())
             );
@@ -275,7 +343,7 @@ impl WaybarModule for BtModule {
                 text,
                 tooltip: Some(tooltip),
                 class: Some(class.join(" ")),
-                percentage: bt_state.battery_percentage,
+                percentage: dev.battery_percentage,
             })
         } else {
             Ok(WaybarOutput {

src/modules/dnd.rs

@@ -5,11 +5,44 @@ use crate::output::WaybarOutput;
 use crate::state::{AppReceivers, DndState};
 use futures::StreamExt;
 use tokio::sync::watch;
+use tokio::time::Duration;
 use tracing::{debug, error, info};
-use zbus::{Connection, fdo::PropertiesProxy, proxy};
+use zbus::proxy;
+use zbus::zvariant::OwnedValue;
+use zbus::{Connection, fdo::PropertiesProxy};
 
 pub struct DndModule;
 
+/// Read dunst's `paused` property via raw D-Bus call.
+async fn dunst_get_paused(connection: &Connection) -> anyhow::Result<bool> {
+    let reply = connection
+        .call_method(
+            Some("org.freedesktop.Notifications"),
+            "/org/freedesktop/Notifications",
+            Some("org.freedesktop.DBus.Properties"),
+            "Get",
+            &("org.dunstproject.cmd0", "paused"),
+        )
+        .await?;
+    let value: OwnedValue = reply.body().deserialize()?;
+    Ok(bool::try_from(&*value)?)
+}
+
+/// Set dunst's `paused` property via raw D-Bus call.
+async fn dunst_set_paused(connection: &Connection, paused: bool) -> anyhow::Result<()> {
+    let value = zbus::zvariant::Value::from(paused);
+    connection
+        .call_method(
+            Some("org.freedesktop.Notifications"),
+            "/org/freedesktop/Notifications",
+            Some("org.freedesktop.DBus.Properties"),
+            "Set",
+            &("org.dunstproject.cmd0", "paused", value),
+        )
+        .await?;
+    Ok(())
+}
+
 impl WaybarModule for DndModule {
     async fn run(
         &self,
@@ -28,7 +61,7 @@ impl WaybarModule for DndModule {
                         message: format!("DBus connection failed: {}", e),
                     })?;
 
-            // Try toggling SwayNC
+            // Try SwayNC
             if let Ok(proxy) = SwayncControlProxy::new(&connection).await
                 && let Ok(is_dnd) = proxy.dnd().await
             {
@@ -36,11 +69,9 @@ impl WaybarModule for DndModule {
                 return Ok(WaybarOutput::default());
             }
 
-            // Try toggling Dunst
-            if let Ok(proxy) = DunstControlProxy::new(&connection).await
-                && let Ok(is_paused) = proxy.paused().await
-            {
-                let _ = proxy.set_paused(!is_paused).await;
+            // Try Dunst via raw D-Bus
+            if let Ok(is_paused) = dunst_get_paused(&connection).await {
+                let _ = dunst_set_paused(&connection, !is_paused).await;
                 return Ok(WaybarOutput::default());
             }
 
@@ -84,18 +115,6 @@ trait SwayncControl {
     fn set_dnd(&self, value: bool) -> zbus::Result<()>;
 }
 
-#[proxy(
-    interface = "org.dunstproject.cmd0",
-    default_service = "org.freedesktop.Notifications",
-    default_path = "/org/freedesktop/Notifications"
-)]
-trait DunstControl {
-    #[zbus(property)]
-    fn paused(&self) -> zbus::Result<bool>;
-    #[zbus(property)]
-    fn set_paused(&self, value: bool) -> zbus::Result<()>;
-}
-
 impl DndDaemon {
     pub fn new() -> Self {
         Self
@@ -117,11 +136,11 @@ impl DndDaemon {
 
         info!("Connected to D-Bus for DND monitoring");
 
-        // Try SwayNC
+        // Try SwayNC first (signal-based)
         if let Ok(proxy) = SwayncControlProxy::new(&connection).await
             && let Ok(is_dnd) = proxy.dnd().await
         {
-            debug!("Found SwayNC, using it for DND state.");
+            debug!("Found SwayNC, using signal-based DND monitoring");
             let _ = tx.send(DndState { is_dnd });
 
             if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
@@ -141,34 +160,41 @@ impl DndDaemon {
                     }
                 }
             }
+
+            return Err(anyhow::anyhow!("SwayNC DND stream ended"));
         }
 
-        // Try Dunst
-        if let Ok(proxy) = DunstControlProxy::new(&connection).await
-            && let Ok(is_dnd) = proxy.paused().await
-        {
-            debug!("Found Dunst, using it for DND state.");
-            let _ = tx.send(DndState { is_dnd });
+        // Try Dunst via raw D-Bus calls (bypasses zbus proxy issues)
+        match dunst_get_paused(&connection).await {
+            Ok(is_paused) => {
+                info!("Found Dunst, using polling-based DND monitoring");
+                let _ = tx.send(DndState { is_dnd: is_paused });
 
-            if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
-                .destination("org.freedesktop.Notifications")?
-                .path("/org/freedesktop/Notifications")?
-                .build()
-                .await
-            {
-                let mut stream = props_proxy.receive_properties_changed().await?;
-                while let Some(signal) = stream.next().await {
-                    let args = signal.args()?;
-                    if args.interface_name == "org.dunstproject.cmd0"
-                        && let Some(val) = args.changed_properties.get("paused")
-                        && let Ok(is_dnd) = bool::try_from(val)
-                    {
-                        let _ = tx.send(DndState { is_dnd });
+                loop {
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                    match dunst_get_paused(&connection).await {
+                        Ok(is_paused) => {
+                            let current = tx.borrow().is_dnd;
+                            if current != is_paused {
+                                let _ = tx.send(DndState { is_dnd: is_paused });
                             }
                         }
+                        Err(e) => {
+                            debug!("Dunst paused() poll failed: {}", e);
+                            break;
+                        }
                     }
                 }
 
-        Err(anyhow::anyhow!("DND stream ended or daemon not found"))
+                return Err(anyhow::anyhow!("Dunst connection lost"));
+            }
+            Err(e) => {
+                info!("Dunst not available: {}", e);
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "No supported notification daemon found (tried SwayNC, Dunst)"
+        ))
     }
 }

src/registry.rs

@@ -6,53 +6,27 @@ use crate::state::AppReceivers;
 #[allow(unused_imports)]
 use crate::modules::WaybarModule;
 
-pub async fn dispatch(
+macro_rules! gen_dispatch {
+    ($( { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident } )*) => {
+        pub async fn dispatch(
             module_name: &str,
             #[allow(unused)] config: &Config,
             #[allow(unused)] state: &AppReceivers,
             #[allow(unused)] args: &[&str],
-) -> FluxoResult<WaybarOutput> {
+        ) -> FluxoResult<WaybarOutput> {
             if !config.is_module_enabled(module_name) {
                 return Err(FluxoError::Disabled(module_name.to_string()));
             }
 
             match module_name {
-        #[cfg(feature = "mod-network")]
-        "net" | "network" => {
-            crate::modules::network::NetworkModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-hardware")]
-        "cpu" => {
-            crate::modules::cpu::CpuModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-hardware")]
-        "mem" | "memory" => {
-            crate::modules::memory::MemoryModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-hardware")]
-        "disk" => {
-            crate::modules::disk::DiskModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-hardware")]
-        "pool" | "btrfs" => {
-            crate::modules::btrfs::BtrfsModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-audio")]
-        "vol" | "audio" => {
-            crate::modules::audio::AudioModule
-                .run(config, state, args)
-                .await
+                $(
+                    #[cfg(feature = $feature)]
+                    $($name)|+ => {
+                        $module.run(config, state, args).await
                     }
+                )*
+
+                // Dispatch-only modules (no watch channel)
                 #[cfg(feature = "mod-audio")]
                 "mic" => {
                     crate::modules::audio::AudioModule
@@ -60,20 +34,6 @@ pub async fn dispatch(
                         .await
                 }
                 #[cfg(feature = "mod-hardware")]
-        "gpu" => {
-            crate::modules::gpu::GpuModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-hardware")]
-        "sys" => {
-            crate::modules::sys::SysModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-bt")]
-        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(config, state, args).await,
-        #[cfg(feature = "mod-hardware")]
                 "power" => {
                     crate::modules::power::PowerModule
                         .run(config, state, args)
@@ -85,41 +45,27 @@ pub async fn dispatch(
                         .run(config, state, args)
                         .await
                 }
-        #[cfg(feature = "mod-dbus")]
-        "backlight" => {
-            crate::modules::backlight::BacklightModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-dbus")]
-        "kbd" | "keyboard" => {
-            crate::modules::keyboard::KeyboardModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-dbus")]
-        "dnd" => {
-            crate::modules::dnd::DndModule
-                .run(config, state, args)
-                .await
-        }
-        #[cfg(feature = "mod-dbus")]
-        "mpris" => {
-            crate::modules::mpris::MprisModule
+                #[cfg(feature = "mod-hardware")]
+                "pool" | "btrfs" => {
+                    crate::modules::btrfs::BtrfsModule
                         .run(config, state, args)
                         .await
                 }
                 _ => Err(FluxoError::Ipc(format!("Unknown module: {}", module_name))),
             }
-}
+        }
 
-/// Returns the default args used by the signaler when evaluating a module.
-pub fn signaler_default_args(module_name: &str) -> &'static [&'static str] {
+        /// Returns the default args used by the signaler when evaluating a module.
+        pub fn signaler_default_args(module_name: &str) -> &'static [&'static str] {
             match module_name {
-        "disk" => &["/"],
-        "vol" | "audio" => &["sink", "show"],
+                $(
+                    $($name)|+ => &[$($default_arg),*],
+                )*
                 "mic" => &["source", "show"],
-        "bt" | "bluetooth" => &["show"],
                 _ => &[],
             }
+        }
+    };
 }
+
+for_each_watched_module!(gen_dispatch);

src/signaler.rs

@@ -63,7 +63,11 @@ impl WaybarSignaler {
             debug!("Waybar process not found, skipping signal.");
         }
     }
+}
 
+macro_rules! gen_signaler_run {
+    ($( { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident } )*) => {
+        impl WaybarSignaler {
             pub async fn run(mut self, config_lock: Arc<RwLock<Config>>, mut receivers: AppReceivers) {
                 let mut last_outputs: HashMap<&'static str, String> = HashMap::new();
 
@@ -90,146 +94,47 @@ impl WaybarSignaler {
                         };
                     }
 
-            // For disabled features, create futures that never resolve
-            #[cfg(not(feature = "mod-network"))]
-            let net_changed = std::future::pending::<
+                    // Generate cfg-gated futures for each watched module
+                    $(
+                        #[cfg(not(feature = $feature))]
+                        let $field = std::future::pending::<
                             std::result::Result<(), tokio::sync::watch::error::RecvError>,
                         >();
-            #[cfg(feature = "mod-network")]
-            let net_changed = receivers.network.changed();
-
-            #[cfg(not(feature = "mod-hardware"))]
-            let cpu_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-hardware")]
-            let cpu_changed = receivers.cpu.changed();
-
-            #[cfg(not(feature = "mod-hardware"))]
-            let mem_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-hardware")]
-            let mem_changed = receivers.memory.changed();
-
-            #[cfg(not(feature = "mod-hardware"))]
-            let sys_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-hardware")]
-            let sys_changed = receivers.sys.changed();
-
-            #[cfg(not(feature = "mod-hardware"))]
-            let gpu_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-hardware")]
-            let gpu_changed = receivers.gpu.changed();
-
-            #[cfg(not(feature = "mod-hardware"))]
-            let disks_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-hardware")]
-            let disks_changed = receivers.disks.changed();
-
-            #[cfg(not(feature = "mod-bt"))]
-            let bt_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-bt")]
-            let bt_changed = receivers.bluetooth.changed();
-
-            #[cfg(not(feature = "mod-audio"))]
-            let audio_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-audio")]
-            let audio_changed = receivers.audio.changed();
+                        #[cfg(feature = $feature)]
+                        let $field = receivers.$field.changed();
+                    )*
 
+                    // MPRIS scroll tick (special case — not a watched module)
                     #[cfg(not(feature = "mod-dbus"))]
-            let backlight_changed = std::future::pending::<
+                    let mpris_scroll_tick = std::future::pending::<
                         std::result::Result<(), tokio::sync::watch::error::RecvError>,
                     >();
                     #[cfg(feature = "mod-dbus")]
-            let backlight_changed = receivers.backlight.changed();
-
-            #[cfg(not(feature = "mod-dbus"))]
-            let keyboard_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-dbus")]
-            let keyboard_changed = receivers.keyboard.changed();
-
-            #[cfg(not(feature = "mod-dbus"))]
-            let dnd_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-dbus")]
-            let dnd_changed = receivers.dnd.changed();
-
-            #[cfg(not(feature = "mod-dbus"))]
-            let mpris_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-dbus")]
-            let mpris_changed = receivers.mpris.changed();
-
-            #[cfg(not(feature = "mod-dbus"))]
-            let mpris_scroll_tick_changed = std::future::pending::<
-                std::result::Result<(), tokio::sync::watch::error::RecvError>,
-            >();
-            #[cfg(feature = "mod-dbus")]
-            let mpris_scroll_tick_changed = receivers.mpris_scroll_tick.changed();
+                    let mpris_scroll_tick = receivers.mpris_scroll_tick.changed();
 
                     tokio::select! {
-                res = net_changed, if signals.network.is_some() => {
-                    if res.is_ok() { check_and_signal!("net", signals.network); }
-                }
-                res = cpu_changed, if signals.cpu.is_some() => {
-                    if res.is_ok() { check_and_signal!("cpu", signals.cpu); }
-                }
-                res = mem_changed, if signals.memory.is_some() => {
-                    if res.is_ok() { check_and_signal!("mem", signals.memory); }
-                }
-                res = sys_changed, if signals.sys.is_some() => {
-                    if res.is_ok() { check_and_signal!("sys", signals.sys); }
-                }
-                res = gpu_changed, if signals.gpu.is_some() => {
-                    if res.is_ok() { check_and_signal!("gpu", signals.gpu); }
-                }
-                res = disks_changed, if signals.disk.is_some() => {
-                    if res.is_ok() { check_and_signal!("disk", signals.disk); }
-                }
-                res = bt_changed, if signals.bt.is_some() => {
-                    if res.is_ok() { check_and_signal!("bt", signals.bt); }
-                }
-                res = audio_changed, if signals.audio.is_some() => {
+                        $(
+                            res = $field, if signals.$signal.is_some() => {
                                 if res.is_ok() {
-                        check_and_signal!("vol", signals.audio);
-                        check_and_signal!("mic", signals.audio);
+                                    $(check_and_signal!($sig_name, signals.$signal);)+
                                 }
                             }
-                res = backlight_changed, if signals.backlight.is_some() => {
-                    if res.is_ok() { check_and_signal!("backlight", signals.backlight); }
-                }
-                res = keyboard_changed, if signals.keyboard.is_some() => {
-                    if res.is_ok() { check_and_signal!("keyboard", signals.keyboard); }
-                }
-                res = dnd_changed, if signals.dnd.is_some() => {
-                    if res.is_ok() { check_and_signal!("dnd", signals.dnd); }
-                }
-                res = mpris_changed, if signals.mpris.is_some() => {
-                    if res.is_ok() { check_and_signal!("mpris", signals.mpris); }
-                }
-                res = mpris_scroll_tick_changed, if signals.mpris.is_some() => {
+                        )*
+
+                        // MPRIS scroll tick (separate from mpris data changes)
+                        res = mpris_scroll_tick, if signals.mpris.is_some() => {
                             if res.is_ok()
                                 && let Some(sig) = signals.mpris { self.send_signal(sig); }
                         }
+
                         _ = sleep(Duration::from_secs(5)) => {
                             // loop and refresh config
                         }
                     }
                 }
             }
+        }
+    };
 }
+
+for_each_watched_module!(gen_signaler_run);

src/state.rs

@@ -4,32 +4,16 @@ use std::sync::Arc;
 use tokio::sync::{RwLock, mpsc, watch};
 use tokio::time::Instant;
 
-#[derive(Clone)]
-pub struct AppReceivers {
-    #[cfg(feature = "mod-network")]
-    pub network: watch::Receiver<NetworkState>,
-    #[cfg(feature = "mod-hardware")]
-    pub cpu: watch::Receiver<CpuState>,
-    #[cfg(feature = "mod-hardware")]
-    pub memory: watch::Receiver<MemoryState>,
-    #[cfg(feature = "mod-hardware")]
-    pub sys: watch::Receiver<SysState>,
-    #[cfg(feature = "mod-hardware")]
-    pub gpu: watch::Receiver<GpuState>,
-    #[cfg(feature = "mod-hardware")]
-    pub disks: watch::Receiver<Vec<DiskInfo>>,
+macro_rules! gen_app_receivers {
+    ($( { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident } )*) => {
+        #[derive(Clone)]
+        pub struct AppReceivers {
+            $(
+                #[cfg(feature = $feature)]
+                pub $field: watch::Receiver<$state>,
+            )*
             #[cfg(feature = "mod-bt")]
-    pub bluetooth: watch::Receiver<BtState>,
-    #[cfg(feature = "mod-audio")]
-    pub audio: watch::Receiver<AudioState>,
-    #[cfg(feature = "mod-dbus")]
-    pub mpris: watch::Receiver<MprisState>,
-    #[cfg(feature = "mod-dbus")]
-    pub backlight: watch::Receiver<BacklightState>,
-    #[cfg(feature = "mod-dbus")]
-    pub keyboard: watch::Receiver<KeyboardState>,
-    #[cfg(feature = "mod-dbus")]
-    pub dnd: watch::Receiver<DndState>,
+            pub bt_cycle: Arc<RwLock<usize>>,
             #[cfg(feature = "mod-dbus")]
             pub mpris_scroll: Arc<RwLock<MprisScrollState>>,
             #[cfg(feature = "mod-dbus")]
@@ -39,7 +23,10 @@ pub struct AppReceivers {
             pub bt_force_poll: mpsc::Sender<()>,
             #[cfg(feature = "mod-audio")]
             pub audio_cmd_tx: mpsc::Sender<crate::modules::audio::AudioCommand>,
+        }
+    };
 }
+for_each_watched_module!(gen_app_receivers);
 
 #[derive(Clone, Default)]
 pub struct ModuleHealth {
@@ -52,7 +39,7 @@ pub struct ModuleHealth {
 #[derive(Default, Clone)]
 pub struct AudioState {
     pub sink: AudioDeviceInfo,
-    pub source: AudioSourceInfo,
+    pub source: AudioDeviceInfo,
     pub available_sinks: Vec<String>,
     pub available_sources: Vec<String>,
 }
@@ -67,24 +54,29 @@ pub struct AudioDeviceInfo {
 }
 
 #[derive(Default, Clone)]
-pub struct AudioSourceInfo {
-    pub name: String,
-    pub description: String,
-    pub volume: u8,
-    pub muted: bool,
-    pub channels: u8,
-}
-
-#[derive(Default, Clone)]
-pub struct BtState {
-    pub connected: bool,
-    pub adapter_powered: bool,
+pub struct BtDeviceInfo {
     pub device_alias: String,
     pub device_address: String,
     pub battery_percentage: Option<u8>,
     pub plugin_data: Vec<(String, String)>,
 }
 
+#[derive(Default, Clone)]
+pub struct BtState {
+    pub adapter_powered: bool,
+    pub devices: Vec<BtDeviceInfo>,
+}
+
+impl BtState {
+    pub fn active_device(&self, index: usize) -> Option<&BtDeviceInfo> {
+        if self.devices.is_empty() {
+            None
+        } else {
+            Some(&self.devices[index % self.devices.len()])
+        }
+    }
+}
+
 #[derive(Default, Clone)]
 pub struct DiskInfo {
     pub mount_point: String,
@@ -295,6 +287,8 @@ pub fn mock_state(state: AppState) -> MockState {
             disks: disks_rx,
             #[cfg(feature = "mod-bt")]
             bluetooth: bt_rx,
+            #[cfg(feature = "mod-bt")]
+            bt_cycle: Arc::new(RwLock::new(0usize)),
             #[cfg(feature = "mod-audio")]
             audio: audio_rx,
             #[cfg(feature = "mod-dbus")]