missing docs

cleanup of gpu and config gen
implemented signals for mpris
2026-04-05 11:56:58 +02:00 · 2026-04-05 11:42:08 +02:00 · 2026-04-05 11:40:31 +02:00 · 2026-04-05 11:38:14 +02:00 · 2026-04-05 11:35:57 +02:00 · 2026-04-04 18:39:15 +02:00
35 changed files with 4321 additions and 1140 deletions
@@ -73,12 +73,155 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 [[package]]
 name = "async-broadcast"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
 dependencies = [
 "event-listener",
 "event-listener-strategy",
 "futures-core",
 "pin-project-lite",
 ]
 [[package]]
 name = "async-channel"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 dependencies = [
 "concurrent-queue",
 "event-listener-strategy",
 "futures-core",
 "pin-project-lite",
 ]
 [[package]]
 name = "async-executor"
 version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
 dependencies = [
 "async-task",
 "concurrent-queue",
 "fastrand",
 "futures-lite",
 "pin-project-lite",
 "slab",
 ]
 [[package]]
 name = "async-io"
 version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
 dependencies = [
 "autocfg",
 "cfg-if",
 "concurrent-queue",
 "futures-io",
 "futures-lite",
 "parking",
 "polling",
 "rustix",
 "slab",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "async-lock"
 version = "3.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
 dependencies = [
 "event-listener",
 "event-listener-strategy",
 "pin-project-lite",
 ]
 [[package]]
 name = "async-process"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
 dependencies = [
 "async-channel",
 "async-io",
 "async-lock",
 "async-signal",
 "async-task",
 "blocking",
 "cfg-if",
 "event-listener",
 "futures-lite",
 "rustix",
 ]
 [[package]]
 name = "async-recursion"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "async-signal"
 version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c"
 dependencies = [
 "async-io",
 "async-lock",
 "atomic-waker",
 "cfg-if",
 "futures-core",
 "futures-io",
 "rustix",
 "signal-hook-registry",
 "slab",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "async-task"
 version = "4.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 [[package]]
 name = "async-trait"
 version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 [[package]]
 name = "autocfg"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 [[package]]
 name = "bitflags"
 version = "2.11.0"
@@ -94,6 +237,19 @@ dependencies = [
 "objc2",
 ]
 [[package]]
 name = "blocking"
 version = "1.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
 dependencies = [
 "async-channel",
 "async-task",
 "futures-io",
 "futures-lite",
 "piper",
 ]
 [[package]]
 name = "bluer"
 version = "0.17.4"
@@ -193,6 +349,21 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 [[package]]
 name = "concurrent-queue"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
 "crossbeam-utils",
 ]
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 [[package]]
 name = "ctrlc"
 version = "3.5.2"
@@ -300,7 +471,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 "block2",
 "libc",
 "objc2",
@@ -323,6 +494,33 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 [[package]]
 name = "endi"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
 dependencies = [
 "enumflags2_derive",
 "serde",
 ]
 [[package]]
 name = "enumflags2_derive"
 version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -339,6 +537,27 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "event-listener"
 version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
 dependencies = [
 "concurrent-queue",
 "parking",
 "pin-project-lite",
 ]
 [[package]]
 name = "event-listener-strategy"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
 dependencies = [
 "event-listener",
 "pin-project-lite",
 ]
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@@ -353,16 +572,18 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 [[package]]
 name = "fluxo-rs"
-version = "0.3.1"
+version = "0.5.1"
 dependencies = [
 "anyhow",
 "bluer",
 "clap",
 "ctrlc",
 "futures",
 "libc",
 "libpulse-binding",
 "maestro",
 "nix 0.31.2",
 "notify",
 "regex",
 "serde",
 "serde_json",
@@ -374,6 +595,7 @@ dependencies = [
 "toml",
 "tracing",
 "tracing-subscriber",
 "zbus",
 ]
 [[package]]
@@ -388,6 +610,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 [[package]]
 name = "fsevent-sys"
 version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "futures"
 version = "0.3.32"
@@ -436,6 +667,19 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 [[package]]
 name = "futures-lite"
 version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
 dependencies = [
 "fastrand",
 "futures-core",
 "futures-io",
 "parking",
 "pin-project-lite",
 ]
 [[package]]
 name = "futures-macro"
 version = "0.3.32"
@@ -510,6 +754,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -530,9 +780,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 [[package]]
 name = "indexmap"
-version = "2.13.0"
+version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "45a8a2b9cb3e0b0c1803dbb0758ffac5de2f425b23c28f518faabd9d805342ff"
 dependencies = [
 "equivalent",
 "hashbrown 0.16.1",
@@ -540,6 +790,26 @@ dependencies = [
 "serde_core",
 ]
 [[package]]
 name = "inotify"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd5b3eaf1a28b758ac0faa5a4254e8ab2705605496f1b1f3fbbc3988ad73d199"
 dependencies = [
 "bitflags 2.11.0",
 "inotify-sys",
 "libc",
 ]
 [[package]]
 name = "inotify-sys"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
@@ -571,6 +841,26 @@ dependencies = [
 "wasm-bindgen",
 ]
 [[package]]
 name = "kqueue"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eac30106d7dce88daf4a3fcb4879ea939476d5074a9b7ddd0fb97fa4bed5596a"
 dependencies = [
 "kqueue-sys",
 "libc",
 ]
 [[package]]
 name = "kqueue-sys"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
 dependencies = [
 "bitflags 1.3.2",
 "libc",
 ]
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -604,7 +894,7 @@ version = "2.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "909eb3049e16e373680fe65afe6e2a722ace06b671250cc4849557bc57d6a397"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 "libc",
 "libpulse-sys",
 "num-derive",
@@ -691,6 +981,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
 dependencies = [
 "libc",
 "log",
 "wasi",
 "windows-sys 0.61.2",
 ]
@@ -707,7 +998,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 "cfg-if",
 "cfg_aliases",
 "libc",
@@ -719,13 +1010,40 @@ version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 "cfg-if",
 "cfg_aliases",
 "libc",
 "memoffset",
 ]
 [[package]]
 name = "notify"
 version = "8.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3"
 dependencies = [
 "bitflags 2.11.0",
 "fsevent-sys",
 "inotify",
 "kqueue",
 "libc",
 "log",
 "mio",
 "notify-types",
 "walkdir",
 "windows-sys 0.60.2",
 ]
 [[package]]
 name = "notify-types"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42b8cfee0e339a0337359f3c88165702ac6e600dc01c0cc9579a92d62b08477a"
 dependencies = [
 "bitflags 2.11.0",
 ]
 [[package]]
 name = "ntapi"
 version = "0.4.3"
@@ -801,7 +1119,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 ]
 [[package]]
@@ -832,6 +1150,22 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 [[package]]
 name = "ordered-stream"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
 dependencies = [
 "futures-core",
 "pin-project-lite",
 ]
 [[package]]
 name = "parking"
 version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 [[package]]
 name = "petgraph"
 version = "0.8.3"
@@ -869,12 +1203,37 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 [[package]]
 name = "piper"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
 dependencies = [
 "atomic-waker",
 "fastrand",
 "futures-io",
 ]
 [[package]]
 name = "pkg-config"
 version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 [[package]]
 name = "polling"
 version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
 dependencies = [
 "cfg-if",
 "concurrent-queue",
 "hermit-abi",
 "pin-project-lite",
 "rustix",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -1004,7 +1363,7 @@ version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 "errno",
 "libc",
 "linux-raw-sys",
@@ -1017,6 +1376,15 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 [[package]]
 name = "same-file"
 version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
 dependencies = [
 "winapi-util",
 ]
 [[package]]
 name = "semver"
 version = "1.0.27"
@@ -1066,6 +1434,17 @@ dependencies = [
 "zmij",
 ]
 [[package]]
 name = "serde_repr"
 version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "serde_spanned"
 version = "1.1.1"
@@ -1270,14 +1649,15 @@ dependencies = [
 "futures-core",
 "futures-sink",
 "pin-project-lite",
 "slab",
 "tokio",
 ]
 [[package]]
 name = "toml"
-version = "1.1.1+spec-1.1.0"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "994b95d9e7bae62b34bab0e2a4510b801fa466066a6a8b2b57361fa1eba068ee"
+checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
 dependencies = [
 "indexmap",
 "serde_core",
@@ -1285,7 +1665,7 @@ dependencies = [
 "toml_datetime",
 "toml_parser",
 "toml_writer",
- "winnow",
+ "winnow 1.0.1",
 ]
 [[package]]
@@ -1299,23 +1679,23 @@ dependencies = [
 [[package]]
 name = "toml_edit"
-version = "0.25.8+spec-1.1.0"
+version = "0.25.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16bff38f1d86c47f9ff0647e6838d7bb362522bdf44006c7068c2b1e606f1f3c"
+checksum = "a82418ca169e235e6c399a84e395ab6debeb3bc90edc959bf0f48647c6a32d1b"
 dependencies = [
 "indexmap",
 "toml_datetime",
 "toml_parser",
- "winnow",
+ "winnow 1.0.1",
 ]
 [[package]]
 name = "toml_parser"
-version = "1.1.1+spec-1.1.0"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39ca317ebc49f06bd748bfba29533eac9485569dc9bf80b849024b025e814fb9"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
- "winnow",
+ "winnow 1.0.1",
 ]
 [[package]]
@@ -1385,6 +1765,17 @@ dependencies = [
 "tracing-log",
 ]
 [[package]]
 name = "uds_windows"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
 dependencies = [
 "memoffset",
 "tempfile",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -1411,6 +1802,7 @@ checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9"
 dependencies = [
 "getrandom",
 "js-sys",
 "serde_core",
 "wasm-bindgen",
 ]
@@ -1420,6 +1812,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 [[package]]
 name = "walkdir"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
 "same-file",
 "winapi-util",
 ]
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"
@@ -1517,7 +1919,7 @@ version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
 "hashbrown 0.15.5",
 "indexmap",
 "semver",
@@ -1539,6 +1941,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 [[package]]
 name = "winapi-util"
 version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
@@ -1652,7 +2063,16 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
 "windows-targets 0.53.5",
 ]
 [[package]]
@@ -1670,14 +2090,31 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
+ "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc",
+ "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu",
+ "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm",
+ "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc",
+ "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu",
+ "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm",
+ "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc",
+ "windows_x86_64_msvc 0.52.6",
 ]
 [[package]]
 name = "windows-targets"
 version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
 dependencies = [
 "windows-link",
 "windows_aarch64_gnullvm 0.53.1",
 "windows_aarch64_msvc 0.53.1",
 "windows_i686_gnu 0.53.1",
 "windows_i686_gnullvm 0.53.1",
 "windows_i686_msvc 0.53.1",
 "windows_x86_64_gnu 0.53.1",
 "windows_x86_64_gnullvm 0.53.1",
 "windows_x86_64_msvc 0.53.1",
 ]
 [[package]]
@@ -1695,48 +2132,105 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 [[package]]
 name = "windows_i686_gnu"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 [[package]]
 name = "windows_i686_msvc"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 [[package]]
 name = "winnow"
 version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 dependencies = [
 "memchr",
 ]
 [[package]]
 name = "winnow"
 version = "1.0.1"
@@ -1804,7 +2298,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
 "anyhow",
- "bitflags",
+ "bitflags 2.11.0",
 "indexmap",
 "log",
 "serde",
@@ -1834,8 +2328,109 @@ dependencies = [
 "wasmparser",
 ]
 [[package]]
 name = "zbus"
 version = "5.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca82f95dbd3943a40a53cfded6c2d0a2ca26192011846a1810c4256ef92c60bc"
 dependencies = [
 "async-broadcast",
 "async-executor",
 "async-io",
 "async-lock",
 "async-process",
 "async-recursion",
 "async-task",
 "async-trait",
 "blocking",
 "enumflags2",
 "event-listener",
 "futures-core",
 "futures-lite",
 "hex",
 "libc",
 "ordered-stream",
 "rustix",
 "serde",
 "serde_repr",
 "tracing",
 "uds_windows",
 "uuid",
 "windows-sys 0.61.2",
 "winnow 0.7.15",
 "zbus_macros",
 "zbus_names",
 "zvariant",
 ]
 [[package]]
 name = "zbus_macros"
 version = "5.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897e79616e84aac4b2c46e9132a4f63b93105d54fe8c0e8f6bffc21fa8d49222"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
 "quote",
 "syn",
 "zbus_names",
 "zvariant",
 "zvariant_utils",
 ]
 [[package]]
 name = "zbus_names"
 version = "4.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f"
 dependencies = [
 "serde",
 "winnow 0.7.15",
 "zvariant",
 ]
 [[package]]
 name = "zmij"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 [[package]]
 name = "zvariant"
 version = "5.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5708299b21903bbe348e94729f22c49c55d04720a004aa350f1f9c122fd2540b"
 dependencies = [
 "endi",
 "enumflags2",
 "serde",
 "winnow 0.7.15",
 "zvariant_derive",
 "zvariant_utils",
 ]
 [[package]]
 name = "zvariant_derive"
 version = "5.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b59b012ebe9c46656f9cc08d8da8b4c726510aef12559da3e5f1bf72780752c"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
 "quote",
 "syn",
 "zvariant_utils",
 ]
 [[package]]
 name = "zvariant_utils"
 version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9"
 dependencies = [
 "proc-macro2",
 "quote",
 "serde",
 "syn",
 "winnow 0.7.15",
 ]
@@ -1,28 +1,40 @@
 [package]
 name = "fluxo-rs"
-version = "0.3.1"
+version = "0.5.1"
 edition = "2024"
 [features]
 default = ["mod-audio", "mod-bt", "mod-network", "mod-hardware", "mod-dbus"]
 mod-audio = ["dep:libpulse-binding"]
 mod-bt = ["dep:bluer", "dep:maestro"]
 mod-network = ["dep:nix"]
 mod-hardware = []
 mod-dbus = ["dep:zbus", "dep:futures"]
 [dependencies]
 anyhow = "1.0.102"
 clap = { version = "4.6.0", features = ["derive"] }
 ctrlc = "3"
 libc = "0.2"
 regex = "1.12"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 sysinfo = "0.38.4"
 thiserror = "2.0"
-toml = "1.1.1"
+toml = "1.1.2"
 tracing = "0.1.44"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
-maestro = { git = "https://github.com/qzed/pbpctrl", package = "maestro" }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal", "process", "io-util", "net"] }
-bluer = { version = "0.17", features = ["bluetoothd", "rfcomm", "id"] }
+tokio-util = { version = "0.7", features = ["codec", "time"] }
-tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal"] }
+notify = "8.2.0"
-tokio-util = { version = "0.7", features = ["codec"] }
+
-futures = "0.3"
+# Optional module dependencies
-libpulse-binding = "2.30"
+maestro = { git = "https://github.com/qzed/pbpctrl", package = "maestro", optional = true }
-nix = { version = "0.31", features = ["net"] }
+bluer = { version = "0.17", features = ["bluetoothd", "rfcomm", "id"], optional = true }
 futures = { version = "0.3", optional = true }
 libpulse-binding = { version = "2.30", optional = true }
 nix = { version = "0.31", features = ["net"], optional = true }
 zbus = { version = "5", optional = true }
 [dev-dependencies]
 tempfile = "3"
@@ -1,18 +1,16 @@
 # fluxo-rs
-fluxo-rs is a high-performance system metrics daemon and client designed specifically for Waybar. It replaces standard shell scripts with a compiled Rust binary that collects data via a background polling loop and serves it over a Unix socket.
+`fluxo-rs` is a high-performance system metrics daemon and client designed specifically for Waybar. It entirely replaces standard shell scripts with a compiled Rust binary that collects data via a background polling loop and serves it over a Unix socket. 
 With its **100% Native, Content-Based Event-Driven Architecture**, it consumes effectively 0% CPU while idle and signals Waybar to redraw *only* when the rendered UI text or icons physically change.
 ## Key Features
- **Asynchronous Architecture**: Built on **Tokio**, the daemon handles concurrent IPC requests and background tasks with zero latency and minimal CPU overhead.
+- **100% Native Architecture**: Zero shell-outs or subprocesses. Uses `bluer` for Bluetooth, `libpulse-binding` for audio, `zbus` for MPRIS/DND, and `notify` for backlight.
- **Native Library Integrations**: 
+- **Content-Based Event Signaling**: `fluxo-rs` evaluates your custom configuration formats internally. It only sends a `SIGRTMIN+X` signal to Waybar if the resulting string or CSS class has actually changed, eliminating pointless re-renders from raw polling fluctuations.
-    - **Audio**: Direct `libpulse` integration for event-driven, instant volume and device updates.
+- **Zero-Latency Interactions**: Direct library bindings mean that when you change your volume or connect a Bluetooth device via the CLI, the daemon updates instantly.
-    - **Bluetooth**: Native `bluer` integration for robust device monitoring.
+- **Circuit Breaker (Failsafe)**: Automatically detects failing modules and enters a "Cool down" state, preventing resource waste and log spam. Fallback caching keeps your bar looking clean even during brief failures.
-    - **Pixel Buds Pro**: Custom native RPC implementation for real-time battery and ANC control.
+- **Multi-threaded Polling**: Decoupled Tokio subsystem threads ensure that a hang in one system (e.g., a slow GPU probe) never freezes your Waybar.
    - **Network**: Native `nix` and `/proc` inspection for high-speed interface monitoring.
    - **Hyprland**: Direct IPC Unix socket communication for gamemode and animation status.
 - **Circuit Breaker (Failsafe)**: Automatically detects failing modules and enters a "Cool down" state to prevent resource waste and log spam.
 - **Multi-threaded Polling**: Decoupled subsystem threads ensure that a hang in one system (e.g., a slow GPU probe) never freezes your entire bar.
 ## Modules
@@ -24,37 +22,47 @@ fluxo-rs is a high-performance system metrics daemon and client designed specifi
 | `sys` | System load and uptime | `{uptime}`, `{load1}`, `{load5}`, `{load15}`, `{procs}` |
 | `disk` | Disk usage | `{mount}`, `{used}`, `{total}` |
 | `pool` | Btrfs aggregate storage | `{used}`, `{total}` |
 | `gpu` | GPU usage & thermals | `{usage}`, `{vram_used}`, `{vram_total}`, `{temp}` |
 | `vol` | Audio output (sink) | `{name}`, `{volume}`, `{icon}` |
 | `mic` | Audio input (source) | `{name}`, `{volume}`, `{icon}` |
 | `bt` | Bluetooth status & plugins | `{alias}`, `{mac}`, `{left}`, `{right}`, `{anc}` |
 | `power` | Battery and AC status | `{percentage}`, `{icon}` |
-| `game` | Hyprland status | active/inactive icons |
+| `game` | Hyprland Gamemode status | active/inactive strings |
 | `mpris` | Media Player status | `{artist}`, `{title}`, `{album}`, `{status_icon}` |
 | `backlight` | Display Brightness | `{percentage}`, `{icon}` |
 | `kbd` | Keyboard Layout | `{layout}` |
 | `dnd` | Do Not Disturb (SwayNC) | active/inactive strings |
 ## Setup
 1. **Build**: `cargo build --release`
-2. **Configure**: Create `~/.config/fluxo/config.toml` (see `example.config.toml`).
+2. **Configure**: Create `~/.config/fluxo/config.toml` (see `example.config.toml`). Ensure you map your `[signals]`.
-3. **Daemon**: Start `fluxo-rs daemon`. It's recommended to run this as a systemd user service.
+3. **Daemon**: Start `fluxo-rs daemon`. It is highly recommended to run this as a systemd user service.
 ## Waybar Configuration
-To achieve zero-latency updates, use **Waybar Signals**:
+To achieve zero-latency updates and zero-polling CPU usage, set `interval: 0` on your modules and rely entirely on **Waybar Signals** mapped in your `config.toml`:
 ```jsonc
-"custom/audio": {
+"custom/volume": {
-    "exec": "fluxo vol",
+    "exec": "fluxo-rs vol",
    "return-type": "json",
-    "interval": 5,
+    "interval": 0,
-    "signal": 8,
+    "signal": 8, // Must match the value in config.toml [signals]
-    "on-click": "fluxo audio cycle sink && pkill -RTMIN+8 waybar"
+    "on-click": "fluxo-rs vol mute",
    "on-scroll-up": "fluxo-rs vol up 1",
    "on-scroll-down": "fluxo-rs vol down 1",
    "on-click-right": "fluxo-rs vol cycle"
 },
-"custom/bluetooth": {
+"custom/bluetooth-audio": {
-    "exec": "fluxo bt",
+    "format": "{}",
    "return-type": "json",
-    "interval": 5,
+    "exec": "fluxo-rs bt",
    "on-click": "fluxo-rs bt menu",
    "on-click-right": "fluxo-rs bt cycle_mode",
    "signal": 9,
-    "on-click": "fluxo bt menu && pkill -RTMIN+9 waybar",
+    "interval": 0,
-    "on-click-right": "fluxo bt cycle_mode && pkill -RTMIN+9 waybar"
+    "tooltip": true
 }
 ```
@@ -1,46 +1,116 @@
 # Fluxo configuration example
 # Place this at ~/.config/fluxo/config.toml
 # Note: All tokens support standard alignment, padding, and precision specifiers dynamically.
 # For example, you can change {rx:>5.2} to {rx:<8.1} or {used} to {used:^4.0} directly here.
 [general]
-menu_command = "fuzzel --dmenu --prompt '{prompt}'"
+# command used for interactive menus (e.g., bluetooth device selection)
 # $FLUXO_PROMPT is securely injected to prevent shell escaping issues
 menu_command = "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
 # For Wofi use: menu_command = "wofi --show dmenu --prompt \"$FLUXO_PROMPT\""
 # Map modules to specific Waybar signals for zero-latency, event-driven UI updates.
 # These MUST match the `signal` configuration in your waybar config.jsonc
 [signals]
 network = 1
 cpu = 2
 memory = 3
 gpu = 4
 sys = 5
 disk = 6
 game = 7
 audio = 8
 bt = 9
 power = 10
 keyboard = 11
 mpris = 12
 backlight = 13
 dnd = 14
 [network]
-format = "{interface} ({ip}):  {rx:>5.2} MB/s   {tx:>5.2} MB/s"
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {interface}, {ip}, {rx}, {tx}
 format = "{interface} ({ip}):  {rx:^4.1} MB/s   {tx:^4.1} MB/s"
 [cpu]
-format = "CPU: {usage:>4.1}% {temp:>4.1}C"
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {usage}, {temp}, {model}
 format = "CPU: {usage:^4.1}% {temp:^4.1}C"
 [memory]
-format = "{used:>5.2}/{total:>5.2}GB"
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {used}, {total}
 format = "MEM: {used:^4.1}/{total:^4.1}GB"
 [gpu]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {usage}, {vram_used}, {vram_total}, {temp}
 format_amd = "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
 format_intel = "iGPU: {usage:>3.0}%"
 format_nvidia = "NV: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
 [sys]
-format = "UP: {uptime} | LOAD: {load1:>4.2} {load5:>4.2} {load15:>4.2}"
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {uptime}, {load1}, {load5}, {load15}, {procs}
 format = "UP: {uptime} LOAD: {load1:^3.1} "
 [disk]
-format = "{mount} {used:>5.1}/{total:>5.1}G"
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {mount}, {used}, {total}
 format = "{mount} {used:^3.0}/{total:^3.0}G"
 [pool]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {used}, {total}
 format = "{used:>4.0}G / {total:>4.0}G"
 [power]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {percentage}, {icon}
 format = "{percentage:>3}%  {icon}"
 [bt]
 format_connected = "{alias} 󰂰"
 format_plugin = "{alias} [{left}|{right}] {anc} 󰂰"
 format_disconnected = "󰂯"
 format_disabled = "󰂲 Off"
 [audio]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {name}, {volume}, {icon}
 format_sink_unmuted = "{name} {volume:>3}% {icon}"
 format_sink_muted = "{name} {icon}"
 format_source_unmuted = "{name} {volume:>3}% {icon}"
 format_source_muted = "{name} {icon}"
 [bt]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {alias}, {mac}, {left}, {right}, {anc}
 format_plugin = "{alias} [{left}|{right}] {anc} 󰂰"
 format_connected = "󰂰 {alias}"
 format_disconnected = "󰂯 Disconnected"
 format_disabled = "󰂲 Off"
 [game]
 # enabled = false  # set to false to disable this module at runtime
 format_active = "<span size='large'>󰊖</span>"
 format_inactive = "<span size='large'></span>"
 [mpris]
 # enabled = false  # set to false to disable this module at runtime
 # max_length = 30          # truncate text beyond this character length (adds '...')
 # scroll = true            # enable marquee scroll animation (requires max_length)
 # scroll_speed = 500       # ms between scroll steps (only while playing)
 # scroll_separator = " /// "  # separator shown between loops when scrolling
 # tokens: {artist}, {title}, {album}, {status_icon}
 format = "{status_icon} {artist} - {title}"
 [backlight]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {percentage}, {icon}
 format = "{percentage:>3}% {icon}"
 [keyboard]
 # enabled = false  # set to false to disable this module at runtime
 # tokens: {layout}
 format = "{layout}"
 [dnd]
 # enabled = false  # set to false to disable this module at runtime
 format_dnd = "<span size='large'>󰂛</span>"
 format_normal = "<span size='large'>󰂚</span>"
@@ -1,92 +1,163 @@
-use regex::Regex;
+//! Configuration loading + top-level `Config` struct.
 //!
 //! Every module section `#[derive(Deserialize)]`s its own struct with `serde`
 //! defaults, so missing TOML sections/fields simply fall back to baked-in
 //! values. The live `Config` is held behind an `Arc<RwLock<_>>` by the daemon
 //! and replaced atomically on reload (see [`crate::daemon::reload_config`]).
 use serde::Deserialize;
 use std::fs;
 use std::path::PathBuf;
 use std::sync::LazyLock;
 use tracing::{debug, info, warn};
 /// Top-level parsed `config.toml`. Each field corresponds to a `[section]`.
 #[derive(Deserialize, Default, Clone)]
 pub struct Config {
    #[serde(default)]
    pub general: GeneralConfig,
    #[serde(default)]
    pub signals: SignalsConfig,
    #[cfg(feature = "mod-network")]
    #[serde(default)]
    pub network: NetworkConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub cpu: CpuConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub memory: MemoryConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub gpu: GpuConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub sys: SysConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub disk: DiskConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub pool: PoolConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub power: PowerConfig,
    #[cfg(feature = "mod-audio")]
    #[serde(default)]
    pub audio: AudioConfig,
    #[cfg(feature = "mod-bt")]
    #[serde(default)]
    pub bt: BtConfig,
    #[cfg(feature = "mod-hardware")]
    #[serde(default)]
    pub game: GameConfig,
    #[cfg(feature = "mod-dbus")]
    #[serde(default)]
    pub mpris: MprisConfig,
    #[cfg(feature = "mod-dbus")]
    #[serde(default)]
    pub backlight: BacklightConfig,
    #[cfg(feature = "mod-dbus")]
    #[serde(default)]
    pub keyboard: KeyboardConfig,
    #[cfg(feature = "mod-dbus")]
    #[serde(default)]
    pub dnd: DndConfig,
 }
 /// Process-wide settings that aren't tied to a single module.
 #[derive(Deserialize, Clone)]
 pub struct GeneralConfig {
    /// Shell command spawned by [`crate::utils::show_menu`] for interactive pickers.
    pub menu_command: String,
 }
 impl Default for GeneralConfig {
    fn default() -> Self {
        Self {
-            menu_command: "fuzzel --dmenu --prompt '{prompt}'".to_string(),
+            menu_command: "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\"".to_string(),
        }
    }
 }
 /// Which Waybar `SIGRTMIN+N` signal each module should trigger, if any.
 ///
 /// `None` disables signalling for that module entirely.
 #[allow(dead_code)]
 #[derive(Deserialize, Default, Clone)]
 pub struct SignalsConfig {
    pub network: Option<i32>,
    pub cpu: Option<i32>,
    pub memory: Option<i32>,
    pub gpu: Option<i32>,
    pub sys: Option<i32>,
    pub disk: Option<i32>,
    pub pool: Option<i32>,
    pub power: Option<i32>,
    pub audio: Option<i32>,
    pub bt: Option<i32>,
    pub game: Option<i32>,
    pub mpris: Option<i32>,
    pub backlight: Option<i32>,
    pub keyboard: Option<i32>,
    pub dnd: Option<i32>,
 }
 /// Network module config. `format` tokens: `interface`, `ip`, `rx`, `tx`.
 #[derive(Deserialize, Clone)]
 pub struct NetworkConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for NetworkConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{interface} ({ip}):  {rx:>5.2} MB/s   {tx:>5.2} MB/s".to_string(),
        }
    }
 }
 /// CPU module config. `format` tokens: `usage`, `temp`.
 #[derive(Deserialize, Clone)]
 pub struct CpuConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for CpuConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "CPU: {usage:>4.1}% {temp:>4.1}C".to_string(),
        }
    }
 }
 /// Memory module config. `format` tokens: `used`, `total` (gigabytes).
 #[derive(Deserialize, Clone)]
 pub struct MemoryConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for MemoryConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{used:>5.2}/{total:>5.2}GB".to_string(),
        }
    }
 }
 /// GPU module config with per-vendor format strings.
 #[derive(Deserialize, Clone)]
 pub struct GpuConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format_amd: String,
    pub format_intel: String,
    pub format_nvidia: String,
@@ -95,6 +166,7 @@ pub struct GpuConfig {
 impl Default for GpuConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format_amd: "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
                .to_string(),
            format_intel: "iGPU: {usage:>3.0}%".to_string(),
@@ -104,60 +176,79 @@ impl Default for GpuConfig {
    }
 }
 /// Sys module config. `format` tokens: `uptime`, `load1`, `load5`, `load15`, `procs`.
 #[derive(Deserialize, Clone)]
 pub struct SysConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for SysConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "UP: {uptime} | LOAD: {load1:>4.2} {load5:>4.2} {load15:>4.2}".to_string(),
        }
    }
 }
 /// Disk module config. `format` tokens: `mount`, `used`, `total`.
 #[derive(Deserialize, Clone)]
 pub struct DiskConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for DiskConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{mount} {used:>5.1}/{total:>5.1}G".to_string(),
        }
    }
 }
 /// Btrfs pool module config. `format` tokens: `used`, `total`.
 #[derive(Deserialize, Clone)]
 pub struct PoolConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for PoolConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{used:>4.0}G / {total:>4.0}G".to_string(),
        }
    }
 }
 /// Battery/power module config. `format` tokens: `percentage`, `icon`.
 #[derive(Deserialize, Clone)]
 pub struct PowerConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for PowerConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{percentage:>3}%  {icon}".to_string(),
        }
    }
 }
 /// Audio module config, one format per (sink|source) × (muted|unmuted) state.
 #[derive(Deserialize, Clone)]
 pub struct AudioConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format_sink_unmuted: String,
    pub format_sink_muted: String,
    pub format_source_unmuted: String,
@@ -167,6 +258,7 @@ pub struct AudioConfig {
 impl Default for AudioConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format_sink_unmuted: "{name} {volume:>3}% {icon}".to_string(),
            format_sink_muted: "{name} {icon}".to_string(),
            format_source_unmuted: "{name} {volume:>3}% {icon}".to_string(),
@@ -175,8 +267,12 @@ impl Default for AudioConfig {
    }
 }
 /// Bluetooth module config. Plugin line tokens: `alias`, `left`, `right`,
 /// `anc`, `mac`. Plain connect line tokens: `alias`.
 #[derive(Deserialize, Clone)]
 pub struct BtConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format_connected: String,
    pub format_plugin: String,
    pub format_disconnected: String,
@@ -186,6 +282,7 @@ pub struct BtConfig {
 impl Default for BtConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format_connected: "{alias} 󰂰".to_string(),
            format_plugin: "{alias} [{left}|{right}] {anc} 󰂰".to_string(),
            format_disconnected: "󰂯".to_string(),
@@ -194,8 +291,11 @@ impl Default for BtConfig {
    }
 }
 /// Gamemode indicator config (active/inactive glyphs).
 #[derive(Deserialize, Clone)]
 pub struct GameConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format_active: String,
    pub format_inactive: String,
 }
@@ -203,17 +303,110 @@ pub struct GameConfig {
 impl Default for GameConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format_active: "<span size='large'>󰊖</span>".to_string(),
            format_inactive: "<span size='large'></span>".to_string(),
        }
    }
 }
-static TOKEN_RE: LazyLock<Regex> =
+/// MPRIS module config. `format` tokens: `artist`, `title`, `album`,
-    LazyLock::new(|| Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap());
+/// `status_icon`. Optional marquee scrolling when `scroll = true`.
 #[derive(Deserialize, Clone)]
 pub struct MprisConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
    #[serde(default)]
    pub max_length: Option<usize>,
    #[serde(default)]
    pub scroll: bool,
    #[serde(default = "default_scroll_speed")]
    pub scroll_speed: u64,
    #[serde(default = "default_scroll_separator")]
    pub scroll_separator: String,
 }
 fn default_scroll_speed() -> u64 {
    500
 }
 fn default_scroll_separator() -> String {
    " /// ".to_string()
 }
 impl Default for MprisConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{status_icon} {artist} - {title}".to_string(),
            max_length: None,
            scroll: false,
            scroll_speed: 500,
            scroll_separator: " /// ".to_string(),
        }
    }
 }
 /// Backlight module config. `format` tokens: `percentage`, `icon`.
 #[derive(Deserialize, Clone)]
 pub struct BacklightConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for BacklightConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{percentage:>3}% {icon}".to_string(),
        }
    }
 }
 /// Keyboard layout module config. `format` tokens: `layout`.
 #[derive(Deserialize, Clone)]
 pub struct KeyboardConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format: String,
 }
 impl Default for KeyboardConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format: "{layout}".to_string(),
        }
    }
 }
 /// Do-Not-Disturb indicator config (dnd/normal glyphs).
 #[derive(Deserialize, Clone)]
 pub struct DndConfig {
    #[serde(default = "default_true")]
    pub enabled: bool,
    pub format_dnd: String,
    pub format_normal: String,
 }
 fn default_true() -> bool {
    true
 }
 impl Default for DndConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            format_dnd: "<span size='large'>󰂛</span>".to_string(),
            format_normal: "<span size='large'>󰂚</span>".to_string(),
        }
    }
 }
 fn extract_tokens(format_str: &str) -> Vec<String> {
-    TOKEN_RE
+    crate::utils::TOKEN_RE
        .captures_iter(format_str)
        .map(|cap| cap[1].to_string())
        .collect()
@@ -231,12 +424,43 @@ fn validate_format(label: &str, format_str: &str, known_tokens: &[&str]) {
 }
 impl Config {
    /// Check if a module is enabled in the configuration.
    /// Returns false if the module is explicitly disabled; true if enabled or unknown.
    pub fn is_module_enabled(&self, module_name: &str) -> bool {
        macro_rules! gen_enabled_match {
            ($( { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident } )*) => {
                match module_name {
                    $(
                        #[cfg(feature = $feature)]
                        $($name)|+ => self.$config.enabled,
                    )*
                    // Dispatch-only modules (no watch channel)
                    #[cfg(feature = "mod-audio")]
                    "mic" => self.audio.enabled,
                    #[cfg(feature = "mod-hardware")]
                    "pool" | "btrfs" => self.pool.enabled,
                    #[cfg(feature = "mod-hardware")]
                    "power" => self.power.enabled,
                    #[cfg(feature = "mod-hardware")]
                    "game" => self.game.enabled,
                    _ => true,
                }
            };
        }
        for_each_watched_module!(gen_enabled_match)
    }
    /// Warn-log any `{token}` placeholders used in format strings that the
    /// corresponding module does not know how to fill in.
    pub fn validate(&self) {
        #[cfg(feature = "mod-network")]
        validate_format(
            "network",
            &self.network.format,
            &["interface", "ip", "rx", "tx"],
        );
        #[cfg(feature = "mod-hardware")]
        {
            validate_format("cpu", &self.cpu.format, &["usage", "temp"]);
            validate_format("memory", &self.memory.format, &["used", "total"]);
            validate_format(
@@ -258,6 +482,9 @@ impl Config {
            validate_format("disk", &self.disk.format, &["mount", "used", "total"]);
            validate_format("pool", &self.pool.format, &["used", "total"]);
            validate_format("power", &self.power.format, &["percentage", "icon"]);
        }
        #[cfg(feature = "mod-audio")]
        {
            validate_format(
                "audio.sink_unmuted",
                &self.audio.format_sink_unmuted,
@@ -278,6 +505,9 @@ impl Config {
                &self.audio.format_source_muted,
                &["name", "icon"],
            );
        }
        #[cfg(feature = "mod-bt")]
        {
            validate_format("bt.connected", &self.bt.format_connected, &["alias"]);
            validate_format(
                "bt.plugin",
@@ -285,10 +515,22 @@ impl Config {
                &["alias", "left", "right", "anc", "mac"],
            );
        }
        #[cfg(feature = "mod-dbus")]
        {
            validate_format(
                "mpris",
                &self.mpris.format,
                &["artist", "title", "album", "status_icon"],
            );
            validate_format("backlight", &self.backlight.format, &["percentage", "icon"]);
            validate_format("keyboard", &self.keyboard.format, &["layout"]);
        }
    }
 }
-pub fn load_config(custom_path: Option<PathBuf>) -> Config {
+/// Resolve the default config path: `$XDG_CONFIG_HOME/fluxo/config.toml`
-    let config_path = custom_path.unwrap_or_else(|| {
+/// (or `~/.config/fluxo/config.toml`).
 pub fn default_config_path() -> PathBuf {
    let config_dir = std::env::var("XDG_CONFIG_HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|_| {
@@ -296,7 +538,12 @@ pub fn load_config(custom_path: Option<PathBuf>) -> Config {
            PathBuf::from(home).join(".config")
        });
    config_dir.join("fluxo/config.toml")
-    });
+}
 /// Load and validate the config, falling back to [`Config::default`] when
 /// the file is missing or malformed. Never panics.
 pub fn load_config(custom_path: Option<PathBuf>) -> Config {
    let config_path = custom_path.unwrap_or_else(default_config_path);
    if let Ok(content) = fs::read_to_string(&config_path) {
        match toml::from_str::<Config>(&content) {
@@ -330,7 +577,7 @@ mod tests {
        let config = Config::default();
        assert_eq!(
            config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
        );
        assert!(config.cpu.format.contains("usage"));
        assert!(config.cpu.format.contains("temp"));
@@ -344,7 +591,7 @@ mod tests {
        // Should fallback to defaults without panicking
        assert_eq!(
            config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
        );
    }
@@ -371,7 +618,7 @@ mod tests {
        // Should fallback to defaults
        assert_eq!(
            config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
        );
    }
@@ -383,7 +630,7 @@ mod tests {
        let config = load_config(Some(tmpfile.path().to_path_buf()));
        assert_eq!(
            config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
        );
        assert!(config.cpu.format.contains("usage"));
    }
@@ -1,21 +1,118 @@
 //! Daemon entry point: orchestrates polling tasks, signal handling, config
 //! hot-reloading, and the IPC server.
 //!
 //! Layout of [`run_daemon`]:
 //!
 //! 1. **Channels** — `watch::channel()` pairs for every module that pushes
 //!    state from a background task.
 //! 2. **Polling / event tasks** — one per module; each writes into its sender,
 //!    the signaler and request handlers read from the matching receiver.
 //! 3. **Config watchers** — filesystem notifier + `SIGHUP` handler refresh the
 //!    [`Config`] in place so modules see updates immediately.
 //! 4. **Signaler** — watches all state receivers and pokes Waybar.
 //! 5. **IPC loop** — `UnixListener` accepting client requests; each connection
 //!    dispatches to [`crate::registry::dispatch`] and returns JSON.
 use crate::config::Config;
 use crate::error::FluxoError;
 use crate::ipc::socket_path;
-use crate::modules::WaybarModule;
+#[cfg(feature = "mod-audio")]
 use crate::modules::audio::AudioDaemon;
 #[cfg(feature = "mod-dbus")]
 use crate::modules::backlight::BacklightDaemon;
 #[cfg(feature = "mod-bt")]
 use crate::modules::bt::BtDaemon;
 #[cfg(feature = "mod-dbus")]
 use crate::modules::dnd::DndDaemon;
 #[cfg(feature = "mod-hardware")]
 use crate::modules::hardware::HardwareDaemon;
 #[cfg(feature = "mod-dbus")]
 use crate::modules::keyboard::KeyboardDaemon;
 #[cfg(feature = "mod-dbus")]
 use crate::modules::mpris::MprisDaemon;
 #[cfg(feature = "mod-network")]
 use crate::modules::network::NetworkDaemon;
-use crate::state::{AppState, SharedState};
+use crate::signaler::WaybarSignaler;
 use crate::state::AppReceivers;
 use anyhow::Result;
 use notify::{Config as NotifyConfig, Event, RecommendedWatcher, RecursiveMode, Watcher};
 use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::UnixListener;
-use tokio::sync::RwLock;
+use tokio::sync::{RwLock, mpsc, watch};
-use tokio::time::{Duration, Instant, sleep};
+use tokio::time::{Duration, sleep};
-use tracing::{debug, error, info, warn};
+use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, info};
 /// Spawn a health-tracked polling loop.
 ///
 /// Each iteration: skip if in backoff, else await `$poll_expr` and feed the
 /// `Result` to [`crate::health::handle_poll_result`]. The loop breaks when
 /// `$token` is cancelled.
 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.
 ///
 /// Identical to [`spawn_poll_loop`] but `$trigger` can wake the loop early —
 /// used by the Bluetooth daemon when a client forces an immediate refresh.
 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 polling loop with no health tracking.
 ///
 /// Used for internal daemons (hardware fast/slow) whose poll functions are
 /// infallible and whose failures don't drive client-visible backoff.
 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,
@@ -28,6 +125,15 @@ impl Drop for SocketGuard {
    }
 }
 fn get_config_path(custom_path: Option<PathBuf>) -> PathBuf {
    custom_path.unwrap_or_else(crate::config::default_config_path)
 }
 /// Run the daemon to completion.
 ///
 /// Sets up the socket, spawns all enabled module tasks, hooks up config
 /// hot-reloading, and finally enters the IPC accept loop. Returns only on
 /// a fatal error or `Ctrl+C`.
 pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
    let sock_path = socket_path();
@@ -36,87 +142,298 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
        fs::remove_file(&sock_path)?;
    }
-    let state: SharedState = Arc::new(RwLock::new(AppState::default()));
+    #[cfg(feature = "mod-network")]
    let (net_tx, net_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-hardware")]
    let (cpu_tx, cpu_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-hardware")]
    let (mem_tx, mem_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-hardware")]
    let (sys_tx, sys_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-hardware")]
    let (gpu_tx, gpu_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-hardware")]
    let (disks_tx, disks_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-bt")]
    let (bt_tx, bt_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-audio")]
    let (audio_tx, audio_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-dbus")]
    let (mpris_tx, mpris_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-dbus")]
    let (backlight_tx, backlight_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-dbus")]
    let (keyboard_tx, keyboard_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-dbus")]
    let (dnd_tx, dnd_rx) = watch::channel(Default::default());
    #[cfg(feature = "mod-dbus")]
    let mpris_scroll = Arc::new(RwLock::new(crate::state::MprisScrollState::default()));
    #[cfg(feature = "mod-dbus")]
    let (mpris_scroll_tick_tx, mpris_scroll_tick_rx) = watch::channel(0u64);
    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);
    let receivers = AppReceivers {
        #[cfg(feature = "mod-network")]
        network: net_rx,
        #[cfg(feature = "mod-hardware")]
        cpu: cpu_rx,
        #[cfg(feature = "mod-hardware")]
        memory: mem_rx,
        #[cfg(feature = "mod-hardware")]
        sys: sys_rx,
        #[cfg(feature = "mod-hardware")]
        gpu: gpu_rx,
        #[cfg(feature = "mod-hardware")]
        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")]
        mpris: mpris_rx,
        #[cfg(feature = "mod-dbus")]
        backlight: backlight_rx,
        #[cfg(feature = "mod-dbus")]
        keyboard: keyboard_rx,
        #[cfg(feature = "mod-dbus")]
        dnd: dnd_rx,
        #[cfg(feature = "mod-dbus")]
        mpris_scroll: Arc::clone(&mpris_scroll),
        #[cfg(feature = "mod-dbus")]
        mpris_scroll_tick: mpris_scroll_tick_rx,
        health: Arc::clone(&health),
        #[cfg(feature = "mod-bt")]
        bt_force_poll: bt_force_tx,
        #[cfg(feature = "mod-audio")]
        audio_cmd_tx,
    };
    let listener = UnixListener::bind(&sock_path)?;
    let _guard = SocketGuard {
        path: sock_path.clone(),
    };
-    // Signal handling for graceful shutdown in async context
+    // Ctrl+C triggers a graceful shutdown by cancelling this token; every
-    let running = Arc::new(tokio::sync::Notify::new());
+    // spawned polling task checks it in its `select!`.
-    let r_clone = Arc::clone(&running);
+    let cancel_token = CancellationToken::new();
    let token_clone = cancel_token.clone();
    tokio::spawn(async move {
        tokio::signal::ctrl_c().await.unwrap();
        info!("Received shutdown signal, exiting...");
-        r_clone.notify_waiters();
+        token_clone.cancel();
    });
-    let config_path_clone = config_path.clone();
+    let resolved_config_path = get_config_path(config_path.clone());
-    let config = Arc::new(RwLock::new(crate::config::load_config(config_path)));
+    let config = Arc::new(RwLock::new(crate::config::load_config(config_path.clone())));
    spawn_config_watchers(&config, &resolved_config_path);
-    // 1. Network Task
+    #[cfg(feature = "mod-network")]
-    let poll_state = Arc::clone(&state);
+    if config.read().await.network.enabled {
    tokio::spawn(async move {
        info!("Starting Network polling task");
        let mut daemon = NetworkDaemon::new();
-        loop {
+        let token = cancel_token.clone();
-            daemon.poll(Arc::clone(&poll_state)).await;
+        let h = Arc::clone(&health);
-            sleep(Duration::from_secs(1)).await;
+        spawn_poll_loop!(
            "net",
            Duration::from_secs(1),
            h,
            token,
            daemon.poll(&net_tx)
        );
    }
    });
-    // 2. Fast Hardware Task (CPU, Mem, Load)
+    // Fast-cycle hardware (cpu/mem/load) polled at 1 Hz.
-    let poll_state = Arc::clone(&state);
+    #[cfg(feature = "mod-hardware")]
-    tokio::spawn(async move {
+    {
-        info!("Starting Fast Hardware polling task");
+        let cfg = config.read().await;
        let fast_enabled = cfg.cpu.enabled || cfg.memory.enabled || cfg.sys.enabled;
        drop(cfg);
        if fast_enabled {
            let mut daemon = HardwareDaemon::new();
-        loop {
+            let token = cancel_token.clone();
-            daemon.poll_fast(Arc::clone(&poll_state)).await;
+            spawn_poll_loop_simple!(
-            sleep(Duration::from_secs(1)).await;
+                "fast_hw",
                Duration::from_secs(1),
                token,
                daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx)
            );
        }
    }
    });
-    // 3. Slow Hardware Task (GPU, Disks)
+    // Slow-cycle hardware (gpu/disks) polled every 5 s — expensive to sample.
-    let poll_state = Arc::clone(&state);
+    #[cfg(feature = "mod-hardware")]
-    tokio::spawn(async move {
+    {
-        info!("Starting Slow Hardware polling task");
+        let cfg = config.read().await;
        let slow_enabled = cfg.gpu.enabled || cfg.disk.enabled;
        drop(cfg);
        if slow_enabled {
            let mut daemon = HardwareDaemon::new();
-        loop {
+            let token = cancel_token.clone();
-            daemon.poll_slow(Arc::clone(&poll_state)).await;
+            spawn_poll_loop_simple!(
-            sleep(Duration::from_secs(1)).await;
+                "slow_hw",
                Duration::from_secs(5),
                token,
                daemon.poll_slow(&gpu_tx, &disks_tx)
            );
        }
    }
    });
-    // 4. Bluetooth Task
+    #[cfg(feature = "mod-bt")]
-    let poll_state = Arc::clone(&state);
+    if config.read().await.bt.enabled {
    let poll_config = Arc::clone(&config);
    tokio::spawn(async move {
        info!("Starting Bluetooth polling task");
        let mut daemon = BtDaemon::new();
-        loop {
+        let token = cancel_token.clone();
        let h = Arc::clone(&health);
        let poll_config = Arc::clone(&config);
        let poll_receivers = receivers.clone();
        spawn_poll_loop_triggered!("bt", Duration::from_secs(2), h, token, bt_force_rx, async {
            let config = poll_config.read().await;
-            daemon.poll(Arc::clone(&poll_state), &config).await;
+            daemon.poll(&bt_tx, &poll_receivers, &config).await;
-            sleep(Duration::from_secs(1)).await;
+            Ok(())
        }
        });
    }
-    // 5. Audio Thread (Event driven - pulse usually needs its own thread)
+    // Event-driven subsystems — these spawn their own threads internally and
    // push into their watch sender as events arrive (no polling loop).
    #[cfg(feature = "mod-audio")]
    if config.read().await.audio.enabled {
        let audio_daemon = AudioDaemon::new();
-    audio_daemon.start(Arc::clone(&state));
+        audio_daemon.start(&audio_tx, audio_cmd_rx);
    }
    #[cfg(feature = "mod-dbus")]
    if config.read().await.backlight.enabled {
        let backlight_daemon = BacklightDaemon::new();
        backlight_daemon.start(backlight_tx);
    }
    #[cfg(feature = "mod-dbus")]
    if config.read().await.keyboard.enabled {
        let keyboard_daemon = KeyboardDaemon::new();
        keyboard_daemon.start(keyboard_tx);
    }
    #[cfg(feature = "mod-dbus")]
    if config.read().await.dnd.enabled {
        let dnd_daemon = DndDaemon::new();
        dnd_daemon.start(dnd_tx);
    }
    #[cfg(feature = "mod-dbus")]
    if config.read().await.mpris.enabled {
        let mpris_daemon = MprisDaemon::new();
        mpris_daemon.start(mpris_tx);
        // Ticks the scroll offset forward for the marquee animation.
        let scroll_config = Arc::clone(&config);
        let scroll_rx = receivers.mpris.clone();
        let scroll_state = Arc::clone(&mpris_scroll);
        tokio::spawn(async move {
            crate::modules::mpris::mpris_scroll_ticker(
                scroll_config,
                scroll_rx,
                scroll_state,
                mpris_scroll_tick_tx,
            )
            .await;
        });
    }
    let signaler = WaybarSignaler::new();
    let sig_config = Arc::clone(&config);
    let sig_receivers = receivers.clone();
    tokio::spawn(async move {
        info!("Starting Waybar Signaler task");
        signaler.run(sig_config, sig_receivers).await;
    });
    info!("Fluxo daemon successfully bound to socket: {}", sock_path);
    run_ipc_loop(listener, receivers, config, config_path, cancel_token).await
 }
 /// Spawn background tasks that hot-reload the daemon's [`Config`].
 ///
 /// Installs a `notify`-based filesystem watcher on the config file's parent
 /// directory, plus a `SIGHUP` handler — either triggers a reload of the
 /// shared `Arc<RwLock<Config>>`.
 fn spawn_config_watchers(config: &Arc<RwLock<Config>>, resolved_path: &std::path::Path) {
    // `notify` recursively tracks the parent dir so atomic-write editors
    // (which rename a new file into place) still get picked up.
    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! {
-            _ = running.notified() => {
+                _ = ev_rx.recv() => {
-                break;
+                    // Coalesce rapid editor writes into one reload.
                    sleep(Duration::from_millis(100)).await;
                    while ev_rx.try_recv().is_ok() {}
                    reload_config(&watcher_config, Some(watcher_path.clone())).await;
                }
            }
        }
    });
    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;
        }
    });
 }
 /// Accept loop for the client Unix socket.
 ///
 /// Each client request spawns a short-lived task that reads one line, looks
 /// up the module via [`crate::registry::dispatch`], and writes the JSON
 /// response back. Broken-pipe errors are logged at `debug` — they just mean
 /// the client timed out before we responded.
 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, _)) => {
-                        let state_clone = Arc::clone(&state);
+                        let state_clone = receivers.clone();
                        let config_clone = Arc::clone(&config);
-                        let cp_clone = config_path_clone.clone();
+                        let cp_clone = config_path.clone();
                        tokio::spawn(async move {
                            let (reader, mut writer) = stream.split();
                            let mut reader = BufReader::new(reader);
@@ -134,12 +451,8 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
                            let parts: Vec<&str> = request.split_whitespace().collect();
                            if let Some(module_name) = parts.first() {
                                if *module_name == "reload" {
-                                    info!("Reloading configuration...");
+                                    reload_config(&config_clone, cp_clone).await;
                                    let new_config = crate::config::load_config(cp_clone);
                                    let mut config_lock = config_clone.write().await;
                                    *config_lock = new_config;
                                    let _ = writer.write_all(b"{\"text\":\"ok\"}").await;
                                    info!("Configuration reloaded successfully.");
                                    return;
                                }
@@ -171,131 +484,53 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
    Ok(())
 }
 /// Re-read the configuration file and swap it into the shared lock.
 pub async fn reload_config(config_lock: &Arc<RwLock<Config>>, path: Option<PathBuf>) {
    info!("Reloading configuration...");
    let new_config = crate::config::load_config(path);
    let mut lock = config_lock.write().await;
    *lock = new_config;
    info!("Configuration reloaded successfully.");
 }
 /// Evaluate a module with its signaler-default args and return the JSON body.
 ///
 /// Used by the [`crate::signaler`] to decide whether the module's output has
 /// actually changed before sending Waybar a signal.
 pub async fn evaluate_module_for_signaler(
    module_name: &str,
    state: &AppReceivers,
    config: &Config,
 ) -> Option<String> {
    let args = crate::registry::signaler_default_args(module_name);
    crate::registry::dispatch(module_name, config, state, args)
        .await
        .ok()
        .and_then(|out| serde_json::to_string(&out).ok())
 }
 async fn handle_request(
    module_name: &str,
    args: &[&str],
-    state: &SharedState,
+    state: &AppReceivers,
    config_lock: &Arc<RwLock<Config>>,
 ) -> String {
-    // 1. Check Circuit Breaker status
+    let (is_in_backoff, cached_output) = crate::health::check_backoff(module_name, state).await;
    let is_in_backoff = {
        let lock = state.read().await;
        if let Some(health) = lock.health.get(module_name) {
            if let Some(until) = health.backoff_until {
                Instant::now() < until
            } else {
                false
            }
        } else {
            false
        }
    };
    if is_in_backoff {
-        return format!(
+        return crate::health::backoff_response(module_name, cached_output);
            "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
            module_name
        );
    }
    let config = config_lock.read().await;
    let result = crate::registry::dispatch(module_name, &config, state, args).await;
-    let result = match module_name {
+    crate::health::update_health(module_name, &result, state).await;
        "net" | "network" => {
            crate::modules::network::NetworkModule
                .run(&config, state, args)
                .await
        }
        "cpu" => {
            crate::modules::cpu::CpuModule
                .run(&config, state, args)
                .await
        }
        "mem" | "memory" => {
            crate::modules::memory::MemoryModule
                .run(&config, state, args)
                .await
        }
        "disk" => {
            crate::modules::disk::DiskModule
                .run(&config, state, args)
                .await
        }
        "pool" | "btrfs" => {
            crate::modules::btrfs::BtrfsModule
                .run(&config, state, args)
                .await
        }
        "vol" => {
            crate::modules::audio::AudioModule
                .run(&config, state, &["sink", args.first().unwrap_or(&"show")])
                .await
        }
        "mic" => {
            crate::modules::audio::AudioModule
                .run(&config, state, &["source", args.first().unwrap_or(&"show")])
                .await
        }
        "gpu" => {
            crate::modules::gpu::GpuModule
                .run(&config, state, args)
                .await
        }
        "sys" => {
            crate::modules::sys::SysModule
                .run(&config, state, args)
                .await
        }
        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(&config, state, args).await,
        "power" => {
            crate::modules::power::PowerModule
                .run(&config, state, args)
                .await
        }
        "game" => {
            crate::modules::game::GameModule
                .run(&config, state, args)
                .await
        }
        _ => {
            warn!("Received request for unknown module: '{}'", module_name);
            Err(FluxoError::Ipc(format!("Unknown module: {}", module_name)))
        }
    };
    // 2. Update Health based on result
    {
        let mut lock = state.write().await;
        let health = lock.health.entry(module_name.to_string()).or_default();
        match &result {
            Ok(_) => {
                health.consecutive_failures = 0;
                health.backoff_until = None;
            }
            Err(e) => {
                health.consecutive_failures += 1;
                health.last_failure = Some(Instant::now());
                if health.consecutive_failures >= 3 {
                    // Backoff for 30 seconds after 3 failures
                    health.backoff_until = Some(Instant::now() + Duration::from_secs(30));
                    warn!(module = module_name, error = %e, "Module entered backoff state due to repeated failures");
                }
            }
        }
    }
    match result {
        Ok(output) => serde_json::to_string(&output).unwrap_or_else(|_| "{}".to_string()),
-        Err(e) => {
+        Err(crate::error::FluxoError::Disabled(_)) => {
-            let error_msg = e.to_string();
+            "{\"text\":\"\",\"tooltip\":\"Module disabled\",\"class\":\"disabled\"}".to_string()
            error!(module = module_name, error = %error_msg, "Module execution failed");
            let err_out = crate::output::WaybarOutput {
                text: "\u{200B}Error\u{200B}".to_string(),
                tooltip: Some(error_msg),
                class: Some("error".to_string()),
                percentage: None,
            };
            serde_json::to_string(&err_out).unwrap_or_else(|_| "{}".to_string())
        }
        Err(e) => crate::health::error_response(module_name, &e, cached_output),
    }
 }
@@ -1,5 +1,11 @@
 //! Error types used across the crate.
 use thiserror::Error;
 /// Canonical error type for all fluxo subsystems.
 ///
 /// Errors are categorised so that [`FluxoError::is_transient`] can distinguish
 /// temporary runtime failures (retried with backoff) from permanent ones.
 #[derive(Error, Debug)]
 #[allow(dead_code)]
 pub enum FluxoError {
@@ -18,14 +24,44 @@ pub enum FluxoError {
    #[error("External system error: {0}")]
    System(String),
    #[error("Bluetooth error: {0}")]
    Bluetooth(String),
    #[error("Network error: {0}")]
    Network(String),
    #[error("Hardware error: {0}")]
    Hardware(String),
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Serialization error: {0}")]
    Serialization(#[from] serde_json::Error),
    #[error("Module disabled: {0}")]
    Disabled(String),
    #[error("Other error: {0}")]
    Other(#[from] anyhow::Error),
 }
 impl FluxoError {
    /// Returns `true` for errors that represent likely-transient failures
    /// (IO, external systems, hardware) and should trigger exponential backoff
    /// rather than permanent cooldown.
    pub fn is_transient(&self) -> bool {
        matches!(
            self,
            Self::Io(_)
                | Self::System(_)
                | Self::Bluetooth(_)
                | Self::Network(_)
                | Self::Hardware(_)
                | Self::Module { .. }
        )
    }
 }
 /// Crate-wide `Result` alias using [`FluxoError`].
 pub type Result<T> = std::result::Result<T, FluxoError>;
@@ -0,0 +1,151 @@
 //! Per-module health tracking and exponential backoff.
 //!
 //! Both the IPC request handler (for on-demand module evaluation) and the
 //! background polling loops consult this module. Transient errors increment a
 //! failure counter that grows the cooldown window; permanent errors trigger an
 //! immediate long cooldown.
 use crate::output::WaybarOutput;
 use crate::state::{AppReceivers, ModuleHealth};
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use tokio::time::{Duration, Instant};
 use tracing::{debug, error, info, warn};
 /// Check if a module is in backoff (used by request handler).
 pub async fn check_backoff(
    module_name: &str,
    state: &AppReceivers,
 ) -> (bool, Option<WaybarOutput>) {
    let lock = state.health.read().await;
    if let Some(health) = lock.get(module_name) {
        let in_backoff = health
            .backoff_until
            .is_some_and(|until| Instant::now() < until);
        (in_backoff, health.last_successful_output.clone())
    } else {
        (false, None)
    }
 }
 /// Update health after a request dispatch (used by request handler).
 pub async fn update_health(
    module_name: &str,
    result: &Result<WaybarOutput, crate::error::FluxoError>,
    state: &AppReceivers,
 ) {
    let mut lock = state.health.write().await;
    let health = lock.entry(module_name.to_string()).or_default();
    match result {
        Ok(output) => {
            health.consecutive_failures = 0;
            health.backoff_until = None;
            health.last_successful_output = Some(output.clone());
        }
        Err(crate::error::FluxoError::Disabled(_)) => {}
        Err(e) => {
            health.consecutive_failures += 1;
            health.last_failure = Some(Instant::now());
            if health.consecutive_failures >= 3 {
                health.backoff_until = Some(Instant::now() + Duration::from_secs(30));
                warn!(module = module_name, error = %e, "Module entered backoff state due to repeated failures");
            }
        }
    }
 }
 /// Check if a polling daemon module is in backoff.
 pub async fn is_poll_in_backoff(
    module_name: &str,
    health_lock: &Arc<RwLock<HashMap<String, ModuleHealth>>>,
 ) -> bool {
    let lock = health_lock.read().await;
    if let Some(health) = lock.get(module_name)
        && let Some(until) = health.backoff_until
    {
        return Instant::now() < until;
    }
    false
 }
 /// Update health after a polling daemon result.
 pub async fn handle_poll_result(
    module_name: &str,
    result: crate::error::Result<()>,
    health_lock: &Arc<RwLock<HashMap<String, ModuleHealth>>>,
 ) {
    let mut lock = health_lock.write().await;
    let health = lock.entry(module_name.to_string()).or_default();
    match result {
        Ok(_) => {
            if health.consecutive_failures > 0 {
                info!(
                    module = module_name,
                    "Module recovered after {} failures", health.consecutive_failures
                );
            }
            health.consecutive_failures = 0;
            health.backoff_until = None;
        }
        Err(e) => {
            health.consecutive_failures += 1;
            health.last_failure = Some(Instant::now());
            if !e.is_transient() {
                health.backoff_until = Some(Instant::now() + Duration::from_secs(60));
                error!(module = module_name, error = %e, "Fatal module error, entering long cooldown");
            } else if health.consecutive_failures >= 3 {
                let backoff_secs = 30 * (2u64.pow(health.consecutive_failures.saturating_sub(3)));
                let backoff_secs = backoff_secs.min(3600);
                health.backoff_until = Some(Instant::now() + Duration::from_secs(backoff_secs));
                warn!(module = module_name, error = %e, backoff = backoff_secs, "Repeated transient failures, entering backoff");
            } else {
                debug!(module = module_name, error = %e, "Transient module failure (attempt {})", health.consecutive_failures);
            }
        }
    }
 }
 /// Serialise a response to return while a module is cooling down.
 ///
 /// If a cached successful output exists, it is returned with a `warning` CSS
 /// class appended; otherwise a generic "Cooling down" placeholder is emitted.
 pub fn backoff_response(module_name: &str, cached: Option<WaybarOutput>) -> String {
    if let Some(mut cached) = cached {
        let class = cached.class.unwrap_or_default();
        cached.class = Some(format!("{} warning", class).trim().to_string());
        return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
    }
    format!(
        "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
        module_name
    )
 }
 /// Serialise a fallback response for a module that errored this request.
 ///
 /// Prefers showing the last successful cached output (with a `warning` class)
 /// over a bare error text, to keep the bar visually stable.
 pub fn error_response(
    module_name: &str,
    e: &crate::error::FluxoError,
    cached: Option<WaybarOutput>,
 ) -> String {
    if let Some(mut cached) = cached {
        let class = cached.class.unwrap_or_default();
        cached.class = Some(format!("{} warning", class).trim().to_string());
        return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
    }
    let error_msg = e.to_string();
    error!(module = module_name, error = %error_msg, "Module execution failed");
    let err_out = WaybarOutput {
        text: "\u{200B}Error\u{200B}".to_string(),
        tooltip: Some(error_msg),
        class: Some("error".to_string()),
        percentage: None,
    };
    serde_json::to_string(&err_out).unwrap_or_else(|_| "{}".to_string())
 }
@@ -1,8 +1,16 @@
 //! Client/daemon Unix socket IPC.
 //!
 //! Requests are newline-terminated `module arg1 arg2...` lines; responses are
 //! the daemon's JSON payload written until EOF.
 use std::io::{Read, Write};
 use std::os::unix::net::UnixStream;
 use std::time::Duration;
 use tracing::debug;
 /// Returns the path to the daemon's Unix socket.
 ///
 /// Prefers `$XDG_RUNTIME_DIR/fluxo.sock`, falling back to `/tmp/fluxo.sock`.
 pub fn socket_path() -> String {
    if let Ok(dir) = std::env::var("XDG_RUNTIME_DIR") {
        format!("{}/fluxo.sock", dir)
@@ -11,13 +19,15 @@ pub fn socket_path() -> String {
    }
 }
 /// Send a module invocation to the daemon and return its response body.
 ///
 /// Blocks for up to 5 seconds waiting for the daemon to reply.
 pub fn request_data(module: &str, args: &[&str]) -> anyhow::Result<String> {
    let sock = socket_path();
    debug!(module, ?args, "Connecting to daemon socket: {}", sock);
    let mut stream = UnixStream::connect(&sock)?;
    stream.set_read_timeout(Some(Duration::from_secs(5)))?;
    // Send module and args
    let mut request = module.to_string();
    for arg in args {
        request.push(' ');
@@ -0,0 +1,43 @@
 //! Central declarative macro that registers every watched module.
 //!
 //! Every piece of per-module boilerplate (AppReceivers field, IPC dispatch arm,
 //! signaler future binding, signaler select arm, config enabled-lookup, default
 //! signaler args) is generated from this single table. Adding a new module is
 //! a one-line edit here plus writing the module file itself.
 /// 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       }
        }
    };
 }
@@ -1,9 +1,28 @@
 //! `fluxo` — high-performance daemon/client for Waybar custom modules.
 //!
 //! The binary has two faces:
 //! * `fluxo daemon` — starts a long-lived process that polls system state
 //!   (network, cpu, audio, bluetooth, …) on background tasks and exposes the
 //!   results over a Unix socket. It also sends `SIGRTMIN+N` signals to Waybar
 //!   when module output changes, so the bar refreshes instantly.
 //! * `fluxo <module> [args]` — a tiny client that asks the daemon to evaluate
 //!   a single module and prints the Waybar-compatible JSON to stdout.
 //!
 //! Modules are feature-gated at compile time (`mod-audio`, `mod-bt`, `mod-dbus`,
 //! `mod-hardware`, `mod-network`) and registered centrally via the
 //! [`for_each_watched_module!`] macro in [`mod@macros`].
 #[macro_use]
 mod macros;
 mod config;
 mod daemon;
 mod error;
 mod health;
 mod ipc;
 mod modules;
 mod output;
 mod registry;
 mod signaler;
 mod state;
 mod utils;
@@ -18,7 +37,14 @@ use tracing_subscriber::{EnvFilter, fmt, prelude::*};
 #[command(about = "A high-performance daemon/client for Waybar custom modules", long_about = None)]
 struct Cli {
    #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
    /// Module name to query or interact with
    module: Option<String>,
    /// Arguments to pass to the module
    #[arg(trailing_var_arg = true)]
    args: Vec<String>,
 }
 #[derive(Subcommand)]
@@ -31,51 +57,6 @@ enum Commands {
    },
    /// Reload the daemon configuration
    Reload,
    /// Network speed module
    #[command(alias = "network")]
    Net,
    /// CPU usage and temp module
    Cpu,
    /// Memory usage module
    #[command(alias = "memory")]
    Mem,
    /// Disk usage module (path defaults to /)
    Disk {
        #[arg(default_value = "/")]
        path: String,
    },
    /// Storage pool aggregate module (e.g., btrfs)
    #[command(alias = "btrfs")]
    Pool {
        #[arg(default_value = "btrfs")]
        kind: String,
    },
    /// Audio volume (sink) control
    Vol {
        /// Cycle to the next available output device
        #[arg(short, long)]
        cycle: bool,
    },
    /// Microphone (source) control
    Mic {
        /// Cycle to the next available input device
        #[arg(short, long)]
        cycle: bool,
    },
    /// GPU usage, VRAM, and temp module
    Gpu,
    /// System load average and uptime
    Sys,
    /// Bluetooth audio device status
    #[command(alias = "bluetooth")]
    Bt {
        #[arg(default_value = "show")]
        action: String,
    },
    /// System power and battery status
    Power,
    /// Hyprland gamemode status
    Game,
 }
 fn main() {
@@ -86,7 +67,8 @@ fn main() {
    let cli = Cli::parse();
-    match &cli.command {
+    if let Some(command) = &cli.command {
        match command {
            Commands::Daemon { config } => {
                info!("Starting Fluxo daemon...");
                let rt = tokio::runtime::Builder::new_multi_thread()
@@ -106,63 +88,56 @@ fn main() {
                    process::exit(1);
                }
            },
        Commands::Net => handle_ipc_response(ipc::request_data("net", &[])),
        Commands::Cpu => handle_ipc_response(ipc::request_data("cpu", &[])),
        Commands::Mem => handle_ipc_response(ipc::request_data("mem", &[])),
        Commands::Disk { path } => handle_ipc_response(ipc::request_data("disk", &[path])),
        Commands::Pool { kind } => handle_ipc_response(ipc::request_data("pool", &[kind])),
        Commands::Vol { cycle } => {
            let action = if *cycle { "cycle" } else { "show" };
            handle_ipc_response(ipc::request_data("vol", &[action]));
        }
-        Commands::Mic { cycle } => {
+        return;
            let action = if *cycle { "cycle" } else { "show" };
            handle_ipc_response(ipc::request_data("mic", &[action]));
    }
        Commands::Gpu => handle_ipc_response(ipc::request_data("gpu", &[])),
        Commands::Sys => handle_ipc_response(ipc::request_data("sys", &[])),
        Commands::Bt { action } => {
            if action == "menu" {
                // Client-side execution of the menu
                let config = config::load_config(None);
    if let Some(module) = &cli.module {
        // Bluetooth menu is handled client-side: it needs access to the user's
        // menu command (rofi/dmenu/wofi) which the daemon has no business spawning.
        #[cfg(feature = "mod-bt")]
        if module == "bt" && cli.args.first().map(|s| s.as_str()) == Some("menu") {
            let config = config::load_config(None);
            let mut items = Vec::new();
-                // If connected, show plugin modes and disconnect
+            // Ask the daemon for the device list; tuples are (alias, mac).
-                if let Ok(json_str) = ipc::request_data("bt", &["get_modes"])
+            let mut connected: Vec<(String, String)> = Vec::new();
            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()));
                    }
                }
            }
            for (alias, mac) in &connected {
                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() {
+            if !paired.is_empty() {
                    items.push("Disconnect".to_string());
                }
                items.push("--- Connect Device ---".to_string());
-
+                for (alias, mac) in &paired {
-                let devices_out = match std::process::Command::new("bluetoothctl")
+                    items.push(format!("{} ({})", alias, mac));
                    .args(["devices"])
                    .output()
                {
                    Ok(out) => out,
                    Err(e) => {
                        error!("bluetoothctl not found or failed: {}", e);
                        return;
                    }
                };
                let stdout = String::from_utf8_lossy(&devices_out.stdout);
                for line in stdout.lines() {
                    if line.starts_with("Device ") {
                        let parts: Vec<&str> = line.splitn(3, ' ').collect();
                        if parts.len() == 3 {
                            items.push(format!("{} ({})", parts[2], parts[1]));
                        }
                }
            }
@@ -170,19 +145,36 @@ fn main() {
                if let Ok(selected) =
                    utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
                {
-                        if let Some(mode) = selected.strip_prefix("Mode: ") {
+                    if selected.contains(": Mode: ") {
-                            handle_ipc_response(ipc::request_data("bt", &["set_mode", mode]));
+                        // Parse "<alias>: Mode: <mode> [<MAC>]".
-                        } else if selected == "Disconnect" {
+                        if let Some(bracket_start) = selected.rfind('[')
-                            handle_ipc_response(ipc::request_data("bt", &["disconnect"]));
+                            && 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 ") {
                        // Parse "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
+                        // section header
                    } else if let Some(mac_start) = selected.rfind('(')
                        && let Some(mac_end) = selected.rfind(')')
                    {
                        let mac = &selected[mac_start + 1..mac_end];
-                            let _ = std::process::Command::new("bluetoothctl")
+                        handle_ipc_response(ipc::request_data("bt", &["connect", mac]));
                                .args(["connect", mac])
                                .status();
                    }
                }
            } else {
@@ -190,13 +182,36 @@ fn main() {
            }
            return;
        }
-            handle_ipc_response(ipc::request_data("bt", &[action]));
+
-        }
+        // `vol` and `mic` both dispatch to the audio module; we just prepend
-        Commands::Power => handle_ipc_response(ipc::request_data("power", &[])),
+        // the "sink" / "source" argument so the server picks the right device.
-        Commands::Game => handle_ipc_response(ipc::request_data("game", &[])),
+        let (actual_module, actual_args) = if module == "vol" {
            let mut new_args = vec!["sink".to_string()];
            new_args.extend(cli.args.clone());
            ("vol".to_string(), new_args)
        } else if module == "mic" {
            let mut new_args = vec!["source".to_string()];
            new_args.extend(cli.args.clone());
            ("vol".to_string(), new_args)
        } else {
            (module.clone(), cli.args.clone())
        };
        let args_ref: Vec<&str> = actual_args.iter().map(|s| s.as_str()).collect();
        handle_ipc_response(ipc::request_data(&actual_module, &args_ref));
    } else {
        println!("Please specify a module or command. See --help.");
        process::exit(1);
    }
 }
 /// Post-process the daemon's response for direct output to Waybar.
 ///
 /// Normal spaces are replaced with figure-spaces (U+2007) so Waybar's
 /// proportional font does not jitter between updates, and the text is wrapped
 /// in zero-width spaces (U+200B) as a cosmetic padding trick. Markup strings
 /// (containing `<`) pass through untouched. On IPC failure an `error` output
 /// is emitted and the client exits non-zero.
 fn handle_ipc_response(response: anyhow::Result<String>) {
    match response {
        Ok(json_str) => match serde_json::from_str::<serde_json::Value>(&json_str) {
@@ -2,23 +2,30 @@ use crate::config::Config;
 use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+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::process::Command;
+use std::sync::Arc;
-use std::sync::{Arc, LazyLock};
+use tokio::sync::{mpsc, watch};
 use tracing::error;
-static RUNTIME: LazyLock<tokio::runtime::Runtime> = LazyLock::new(|| {
+pub enum AudioCommand {
-    tokio::runtime::Builder::new_current_thread()
+    ChangeVolume {
-        .enable_all()
+        is_sink: bool,
-        .build()
+        step_val: u32,
-        .expect("Failed to create Audio tokio runtime")
+        is_up: bool,
-});
+    },
    ToggleMute {
        is_sink: bool,
    },
    CycleDevice {
        is_sink: bool,
    },
 }
 pub struct AudioDaemon;
@@ -27,8 +34,12 @@ impl AudioDaemon {
        Self
    }
-    pub fn start(&self, state: SharedState) {
+    pub fn start(
-        let state_arc = Arc::clone(&state);
+        &self,
        state_tx: &watch::Sender<AudioState>,
        mut cmd_rx: mpsc::Receiver<AudioCommand>,
    ) {
        let state_tx = state_tx.clone();
        std::thread::spawn(move || {
            let mut mainloop =
@@ -64,7 +75,7 @@ impl AudioDaemon {
            }
            // Initial fetch
-            let _ = fetch_audio_data_sync(&mut context, &state_arc);
+            let _ = fetch_audio_data_sync(&mut context, &state_tx);
            // Subscribe to events
            let interest =
@@ -72,11 +83,12 @@ impl AudioDaemon {
            context.subscribe(interest, |_| {});
            let (tx, rx) = std::sync::mpsc::channel();
            let tx_cb = tx.clone();
            context.set_subscribe_callback(Some(Box::new(move |facility, _operation, _index| {
                match facility {
                    Some(Facility::Sink) | Some(Facility::Source) | Some(Facility::Server) => {
-                        let _ = tx.send(());
+                        let _ = tx_cb.send(());
                    }
                    _ => {}
                }
@@ -84,14 +96,110 @@ impl AudioDaemon {
            mainloop.unlock();
            // Background polling loop driven by events or a 2s fallback timeout
            loop {
-                let _ = rx.recv_timeout(Duration::from_secs(2));
+                if let Ok(cmd) = cmd_rx.try_recv() {
                {
                    mainloop.lock();
-                    let _ = fetch_audio_data_sync(&mut context, &state_arc);
+                    match cmd {
-                    mainloop.unlock();
+                        AudioCommand::ChangeVolume {
                            is_sink,
                            step_val,
                            is_up,
                        } => {
                            let current = state_tx.borrow().clone();
                            let (name, mut vol, channels) = if is_sink {
                                (
                                    current.sink.name.clone(),
                                    current.sink.volume,
                                    current.sink.channels,
                                )
                            } else {
                                (
                                    current.source.name.clone(),
                                    current.source.volume,
                                    current.source.channels,
                                )
                            };
                            if is_up {
                                vol = vol.saturating_add(step_val as u8).min(150);
                            } else {
                                vol = vol.saturating_sub(step_val as u8);
                            }
                            let pulse_vol = Volume(
                                (vol as f64 / 100.0 * Volume::NORMAL.0 as f64).round() as u32,
                            );
                            let mut cvol = libpulse_binding::volume::ChannelVolumes::default();
                            cvol.set(channels.max(1), pulse_vol);
                            if is_sink {
                                context
                                    .introspect()
                                    .set_sink_volume_by_name(&name, &cvol, None);
                            } else {
                                context
                                    .introspect()
                                    .set_source_volume_by_name(&name, &cvol, None);
                            }
                        }
                        AudioCommand::ToggleMute { is_sink } => {
                            let current = state_tx.borrow().clone();
                            let (name, muted) = if is_sink {
                                (current.sink.name.clone(), current.sink.muted)
                            } else {
                                (current.source.name.clone(), current.source.muted)
                            };
                            if is_sink {
                                context
                                    .introspect()
                                    .set_sink_mute_by_name(&name, !muted, None);
                            } else {
                                context
                                    .introspect()
                                    .set_source_mute_by_name(&name, !muted, None);
                            }
                        }
                        AudioCommand::CycleDevice { is_sink } => {
                            let current = state_tx.borrow().clone();
                            let current_name = if is_sink {
                                current.sink.name.clone()
                            } else {
                                current.source.name.clone()
                            };
                            let devices = if is_sink {
                                &current.available_sinks
                            } else {
                                &current.available_sources
                            };
                            if !devices.is_empty() {
                                let current_idx =
                                    devices.iter().position(|d| d == &current_name).unwrap_or(0);
                                let next_idx = (current_idx + 1) % devices.len();
                                let next_dev = &devices[next_idx];
                                if is_sink {
                                    context.set_default_sink(next_dev, |_| {});
                                } else {
                                    context.set_default_source(next_dev, |_| {});
                                }
                            }
                        }
                    }
                    mainloop.unlock();
                    let _ = tx.send(());
                }
                let _ = rx.recv_timeout(Duration::from_millis(50));
                while rx.try_recv().is_ok() {}
                mainloop.lock();
                // Fetch data and update available sinks/sources
                let _ = fetch_audio_data_sync(&mut context, &state_tx);
                mainloop.unlock();
            }
        });
    }
@@ -99,91 +207,176 @@ impl AudioDaemon {
 use std::time::Duration;
-fn fetch_audio_data_sync(context: &mut Context, state: &SharedState) -> Result<()> {
+fn fetch_audio_data_sync(
-    let state_inner = Arc::clone(state);
+    context: &mut Context,
-
+    state_tx: &watch::Sender<AudioState>,
 ) -> Result<()> {
    // We fetch all sinks and sources, and also server info to know defaults.
    // The order doesn't strictly matter as long as we update correctly.
-    let st_server = Arc::clone(&state_inner);
+    let tx_server = state_tx.clone();
    context.introspect().get_server_info(move |info| {
-        let mut lock = RUNTIME.block_on(st_server.write());
+        let mut current = tx_server.borrow().clone();
-        lock.audio.sink.name = info
+        current.sink.name = info
            .default_sink_name
            .as_ref()
            .map(|s| s.to_string())
            .unwrap_or_default();
-        lock.audio.source.name = info
+        current.source.name = info
            .default_source_name
            .as_ref()
            .map(|s| s.to_string())
            .unwrap_or_default();
        let _ = tx_server.send(current);
    });
-    let st_sink = Arc::clone(&state_inner);
+    fetch_sinks(context, state_tx);
-    context.introspect().get_sink_info_list(move |res| {
+    fetch_sources(context, state_tx);
        if let ListResult::Item(item) = res {
            let mut lock = RUNTIME.block_on(st_sink.write());
            // If this matches our default sink name, or if we don't have details for any yet
            let is_default = item
                .name
                .as_ref()
                .map(|s| s.as_ref() == lock.audio.sink.name)
                .unwrap_or(false);
            if is_default {
                lock.audio.sink.description = item
                    .description
                    .as_ref()
                    .map(|s| s.to_string())
                    .unwrap_or_default();
                lock.audio.sink.volume =
                    ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
                lock.audio.sink.muted = item.mute;
            }
        }
    });
    let st_source = Arc::clone(&state_inner);
    context.introspect().get_source_info_list(move |res| {
        if let ListResult::Item(item) = res {
            let mut lock = RUNTIME.block_on(st_source.write());
            let is_default = item
                .name
                .as_ref()
                .map(|s| s.as_ref() == lock.audio.source.name)
                .unwrap_or(false);
            if is_default {
                lock.audio.source.description = item
                    .description
                    .as_ref()
                    .map(|s| s.to_string())
                    .unwrap_or_default();
                lock.audio.source.volume =
                    ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
                lock.audio.source.muted = item.mute;
            }
        }
    });
    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 {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        args: &[&str],
    ) -> Result<WaybarOutput> {
        let target_type = args.first().unwrap_or(&"sink");
        let action = args.get(1).unwrap_or(&"show");
        let step = args.get(2).unwrap_or(&"5");
        match *action {
            "up" => {
                self.change_volume(state, target_type, step, true).await?;
                self.get_status(config, state, target_type).await
            }
            "down" => {
                self.change_volume(state, target_type, step, false).await?;
                self.get_status(config, state, target_type).await
            }
            "mute" => {
                self.toggle_mute(state, target_type).await?;
                self.get_status(config, state, target_type).await
            }
            "cycle" => {
-                self.cycle_device(target_type)?;
+                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 {
@@ -198,13 +391,10 @@ impl AudioModule {
    async fn get_status(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        target_type: &str,
    ) -> Result<WaybarOutput> {
-        let audio_state = {
+        let audio_state = state.audio.borrow().clone();
            let lock = state.read().await;
            lock.audio.clone()
        };
        let (name, description, volume, muted) = if target_type == "sink" {
            (
@@ -287,69 +477,41 @@ impl AudioModule {
        })
    }
-    fn cycle_device(&self, target_type: &str) -> Result<()> {
+    async fn change_volume(
-        // Keep using pactl for cycling for now as it's a rare action
+        &self,
-        // but we could also implement it natively later.
+        state: &AppReceivers,
-        let set_cmd = if target_type == "sink" {
+        target_type: &str,
-            "set-default-sink"
+        step: &str,
-        } else {
+        is_up: bool,
-            "set-default-source"
+    ) -> Result<()> {
-        };
+        let is_sink = target_type == "sink";
-
+        let step_val: u32 = step.parse().unwrap_or(5);
-        // We need to find the "next" device.
+        let _ = state
-        // For simplicity, let's keep the CLI version for now or refactor later.
+            .audio_cmd_tx
-        // The user asked for "step by step".
+            .send(AudioCommand::ChangeVolume {
-
+                is_sink,
-        let list_cmd = if target_type == "sink" {
+                step_val,
-            "sinks"
+                is_up,
        } else {
            "sources"
        };
        let output = Command::new("pactl")
            .args(["list", "short", list_cmd])
            .output()?;
        let stdout = String::from_utf8_lossy(&output.stdout);
        let devices: Vec<String> = stdout
            .lines()
            .filter_map(|l| {
                let parts: Vec<&str> = l.split_whitespace().collect();
                if parts.len() >= 2 {
                    let name = parts[1].to_string();
                    if target_type == "source" && name.contains(".monitor") {
                        None
                    } else {
                        Some(name)
                    }
                } else {
                    None
                }
            })
-            .collect();
+            .await;
-
+        Ok(())
        if devices.is_empty() {
            return Ok(());
    }
-        let info_output = Command::new("pactl").args(["info"]).output()?;
+    async fn toggle_mute(&self, state: &AppReceivers, target_type: &str) -> Result<()> {
-        let info_stdout = String::from_utf8_lossy(&info_output.stdout);
+        let is_sink = target_type == "sink";
-        let search_key = if target_type == "sink" {
+        let _ = state
-            "Default Sink:"
+            .audio_cmd_tx
-        } else {
+            .send(AudioCommand::ToggleMute { is_sink })
-            "Default Source:"
+            .await;
-        };
+        Ok(())
-        let current_dev = info_stdout
+    }
            .lines()
            .find(|l| l.contains(search_key))
            .and_then(|l| l.split(':').nth(1))
            .map(|s| s.trim())
            .unwrap_or("");
-        let current_index = devices.iter().position(|d| d == current_dev).unwrap_or(0);
+    async fn cycle_device(&self, state: &AppReceivers, target_type: &str) -> Result<()> {
-        let next_index = (current_index + 1) % devices.len();
+        let is_sink = target_type == "sink";
-        let next_dev = &devices[next_index];
+        let _ = state
-
+            .audio_cmd_tx
-        Command::new("pactl").args([set_cmd, next_dev]).status()?;
+            .send(AudioCommand::CycleDevice { is_sink })
            .await;
        Ok(())
    }
 }
@@ -0,0 +1,154 @@
 use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::{AppReceivers, BacklightState};
 use crate::utils::{TokenValue, format_template};
 use notify::{Config as NotifyConfig, Event, RecommendedWatcher, RecursiveMode, Watcher};
 use std::path::PathBuf;
 use std::sync::mpsc;
 use std::time::Duration;
 use tokio::sync::watch;
 use tracing::{error, info};
 pub struct BacklightModule;
 impl WaybarModule for BacklightModule {
    async fn run(
        &self,
        config: &Config,
        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let percentage = state.backlight.borrow().percentage;
        let icon = if percentage < 30 {
            "󰃞"
        } else if percentage < 70 {
            "󰃟"
        } else {
            "󰃠"
        };
        let text = format_template(
            &config.backlight.format,
            &[
                ("percentage", TokenValue::Int(percentage as i64)),
                ("icon", TokenValue::String(icon.to_string())),
            ],
        );
        Ok(WaybarOutput {
            text,
            tooltip: Some(format!("Brightness: {}%", percentage)),
            class: Some("normal".to_string()),
            percentage: Some(percentage),
        })
    }
 }
 pub struct BacklightDaemon;
 impl BacklightDaemon {
    pub fn new() -> Self {
        Self
    }
    pub fn start(&self, tx: watch::Sender<BacklightState>) {
        std::thread::spawn(move || {
            let base_dir = PathBuf::from("/sys/class/backlight");
            let mut device_dir = None;
            if let Ok(entries) = std::fs::read_dir(&base_dir) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    if path.is_dir() {
                        device_dir = Some(path);
                        break;
                    }
                }
            }
            let Some(dir) = device_dir else {
                error!("No backlight device found in /sys/class/backlight");
                return;
            };
            info!("Monitoring backlight device: {:?}", dir);
            let max_brightness_path = dir.join("max_brightness");
            let brightness_path = dir.join("actual_brightness");
            let brightness_path_fallback = dir.join("brightness");
            let target_file = if brightness_path.exists() {
                brightness_path
            } else {
                brightness_path_fallback
            };
            let get_percentage = || -> u8 {
                let max: f64 = std::fs::read_to_string(&max_brightness_path)
                    .unwrap_or_default()
                    .trim()
                    .parse()
                    .unwrap_or(100.0);
                let current: f64 = std::fs::read_to_string(&target_file)
                    .unwrap_or_default()
                    .trim()
                    .parse()
                    .unwrap_or(0.0);
                if max > 0.0 {
                    ((current / max) * 100.0).round() as u8
                } else {
                    0
                }
            };
            // Initial poll
            let _ = tx.send(BacklightState {
                percentage: get_percentage(),
            });
            // Set up notify watcher
            let (ev_tx, ev_rx) = mpsc::channel();
            let mut watcher = RecommendedWatcher::new(
                move |res: notify::Result<Event>| {
                    if let Ok(event) = res
                        && event.kind.is_modify()
                    {
                        let _ = ev_tx.send(());
                    }
                },
                NotifyConfig::default(),
            )
            .unwrap();
            if let Err(e) = watcher.watch(&target_file, RecursiveMode::NonRecursive) {
                error!("Failed to watch backlight file: {}", e);
                return;
            }
            loop {
                // Block until an event occurs or a timeout to catch missed events
                if ev_rx.recv_timeout(Duration::from_secs(5)).is_ok() {
                    // Debounce rapid events
                    std::thread::sleep(Duration::from_millis(50));
                    while ev_rx.try_recv().is_ok() {}
                    let _ = tx.send(BacklightState {
                        percentage: get_percentage(),
                    });
                } else {
                    // Timeout hit, poll just in case
                    let current = get_percentage();
                    if tx.borrow().percentage != current {
                        let _ = tx.send(BacklightState {
                            percentage: current,
                        });
                    }
                }
            }
        });
    }
 }
@@ -1,10 +1,9 @@
 use crate::config::Config;
 use crate::error::{FluxoError, Result as FluxoResult};
-use crate::modules::bt::maestro::{BudsCommand, get_maestro};
+use crate::modules::bt::maestro::BudsCommand;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::TokenValue;
 use futures::future::BoxFuture;
 use std::sync::Arc;
 pub trait BtPlugin: Send + Sync {
    fn name(&self) -> &str;
@@ -12,21 +11,21 @@ pub trait BtPlugin: Send + Sync {
    fn get_data(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        mac: &str,
    ) -> BoxFuture<'static, FluxoResult<Vec<(String, TokenValue)>>>;
    fn get_modes(
        &self,
        mac: &str,
-        state: &SharedState,
+        state: &AppReceivers,
    ) -> BoxFuture<'static, FluxoResult<Vec<String>>>;
    fn set_mode(
        &self,
        mode: &str,
        mac: &str,
-        state: &SharedState,
+        state: &AppReceivers,
    ) -> BoxFuture<'static, FluxoResult<()>>;
-    fn cycle_mode(&self, mac: &str, state: &SharedState) -> BoxFuture<'static, FluxoResult<()>>;
+    fn cycle_mode(&self, mac: &str, state: &AppReceivers) -> BoxFuture<'static, FluxoResult<()>>;
 }
 pub struct PixelBudsPlugin;
@@ -43,13 +42,13 @@ impl BtPlugin for PixelBudsPlugin {
    fn get_data(
        &self,
        _config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        mac: &str,
    ) -> BoxFuture<'static, FluxoResult<Vec<(String, TokenValue)>>> {
        let mac = mac.to_string();
-        let state = Arc::clone(state);
+        let state = state.clone();
        Box::pin(async move {
-            let maestro = get_maestro(&state);
+            let maestro = crate::modules::bt::maestro::get_maestro(&state);
            maestro.ensure_task(&mac);
            let status = maestro.get_status(&mac);
@@ -91,7 +90,7 @@ impl BtPlugin for PixelBudsPlugin {
    fn get_modes(
        &self,
        _mac: &str,
-        _state: &SharedState,
+        _state: &AppReceivers,
    ) -> BoxFuture<'static, FluxoResult<Vec<String>>> {
        Box::pin(async move {
            Ok(vec![
@@ -106,13 +105,13 @@ impl BtPlugin for PixelBudsPlugin {
        &self,
        mode: &str,
        mac: &str,
-        state: &SharedState,
+        state: &AppReceivers,
    ) -> BoxFuture<'static, FluxoResult<()>> {
        let mode = mode.to_string();
        let mac = mac.to_string();
-        let state = Arc::clone(state);
+        let state = state.clone();
        Box::pin(async move {
-            get_maestro(&state)
+            crate::modules::bt::maestro::get_maestro(&state)
                .send_command(&mac, BudsCommand::SetAnc(mode))
                .map_err(|e: anyhow::Error| FluxoError::Module {
                    module: "bt.buds",
@@ -121,17 +120,17 @@ impl BtPlugin for PixelBudsPlugin {
        })
    }
-    fn cycle_mode(&self, mac: &str, state: &SharedState) -> BoxFuture<'static, FluxoResult<()>> {
+    fn cycle_mode(&self, mac: &str, state: &AppReceivers) -> BoxFuture<'static, FluxoResult<()>> {
        let mac = mac.to_string();
-        let state = Arc::clone(state);
+        let state = state.clone();
        Box::pin(async move {
-            let status = get_maestro(&state).get_status(&mac);
+            let status = crate::modules::bt::maestro::get_maestro(&state).get_status(&mac);
            let next_mode = match status.anc_state.as_str() {
                "active" => "aware",
                "aware" => "off",
                _ => "active",
            };
-            get_maestro(&state)
+            crate::modules::bt::maestro::get_maestro(&state)
                .send_command(&mac, BudsCommand::SetAnc(next_mode.to_string()))
                .map_err(|e: anyhow::Error| FluxoError::Module {
                    module: "bt.buds",
@@ -1,4 +1,4 @@
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use anyhow::{Context, Result};
 use futures::StreamExt;
 use std::collections::HashMap;
@@ -39,11 +39,11 @@ pub struct MaestroManager {
 }
 impl MaestroManager {
-    pub fn new(state: SharedState) -> Self {
+    pub fn new(state: AppReceivers) -> Self {
        let (tx, mut rx) = mpsc::unbounded_channel::<ManagerCommand>();
        let statuses = Arc::new(Mutex::new(HashMap::new()));
        let statuses_clone = Arc::clone(&statuses);
-        let state_clone = Arc::clone(&state);
+        let state_clone = state.clone();
        // Start dedicated BT management thread
        std::thread::spawn(move || {
@@ -68,7 +68,7 @@ impl MaestroManager {
                                        let mac_clone = mac.clone();
                                        let st_clone = Arc::clone(&statuses_clone);
-                                        let state_inner = Arc::clone(&state_clone);
+                                        let state_inner = state_clone.clone();
                                        tokio::task::spawn_local(async move {
                                            if let Err(e) = buds_task(&mac_clone, st_clone, buds_rx, state_inner).await {
@@ -122,7 +122,7 @@ async fn buds_task(
    mac: &str,
    statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
    mut rx: mpsc::Receiver<BudsCommand>,
-    state: SharedState,
+    state: AppReceivers,
 ) -> Result<()> {
    info!("Starting native Maestro connection task for {}", mac);
@@ -215,8 +215,8 @@ async fn buds_task(
        // Update health
        {
-            let mut lock = state.write().await;
+            let mut lock = state.health.write().await;
-            let health = lock.health.entry("bt.buds".to_string()).or_default();
+            let health = lock.entry("bt.buds".to_string()).or_default();
            health.consecutive_failures = 0;
            health.backoff_until = None;
        }
@@ -357,6 +357,6 @@ pub fn anc_state_to_string(state: &settings::AncState) -> String {
 static MAESTRO: OnceLock<MaestroManager> = OnceLock::new();
-pub fn get_maestro(state: &SharedState) -> &MaestroManager {
+pub fn get_maestro(state: &AppReceivers) -> &MaestroManager {
-    MAESTRO.get_or_init(|| MaestroManager::new(Arc::clone(state)))
+    MAESTRO.get_or_init(|| MaestroManager::new(state.clone()))
 }
@@ -5,11 +5,11 @@ use crate::config::Config;
 use crate::error::Result as FluxoResult;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::{BtState, SharedState};
+use crate::state::{AppReceivers, BtDeviceInfo, BtState};
 use crate::utils::{TokenValue, format_template};
 use anyhow::Result;
-use std::process::Command;
+use std::sync::LazyLock;
-use std::sync::{Arc, LazyLock};
+use tokio::sync::watch;
 use tracing::{error, warn};
 use self::buds::{BtPlugin, PixelBudsPlugin};
@@ -23,13 +23,23 @@ impl BtDaemon {
        Self { session: None }
    }
-    pub async fn poll(&mut self, state: SharedState, config: &Config) {
+    pub async fn poll(
-        if let Err(e) = self.poll_async(state, config).await {
+        &mut self,
        tx: &watch::Sender<BtState>,
        state: &AppReceivers,
        config: &Config,
    ) {
        if let Err(e) = self.poll_async(tx, state, config).await {
            error!("BT daemon error: {}", e);
        }
    }
-    async fn poll_async(&mut self, state: SharedState, config: &Config) -> Result<()> {
+    async fn poll_async(
        &mut self,
        tx: &watch::Sender<BtState>,
        state: &AppReceivers,
        config: &Config,
    ) -> Result<()> {
        if self.session.is_none() {
            self.session = Some(bluer::Session::new().await?);
        }
@@ -37,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 {
+        let mut connected_devices = Vec::new();
            adapter_powered,
            ..Default::default()
        };
        if adapter_powered {
-            let devices = adapter.device_addresses().await?;
+            let mut addresses = adapter.device_addresses().await?;
-            for addr in devices {
+            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 =
+                if !uuids.contains(&audio_sink_uuid) {
-                        bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
+                    continue;
-                    if uuids.contains(&audio_sink_uuid) {
+                }
-                        bt_state.connected = true;
+
-                        bt_state.device_address = addr.to_string();
+                let mut dev_info = BtDeviceInfo {
-                        bt_state.device_alias =
+                    device_address: addr.to_string(),
-                            device.alias().await.unwrap_or_else(|_| addr.to_string());
+                    device_alias: device.alias().await.unwrap_or_else(|_| addr.to_string()),
-                        bt_state.battery_percentage =
+                    battery_percentage: device.battery_percentage().await.unwrap_or(None),
-                            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) {
+                    if p.can_handle(&dev_info.device_alias, &dev_info.device_address) {
-                                match p.get_data(config, &state, &bt_state.device_address).await {
+                        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 {
@@ -76,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()));
                            }
@@ -84,14 +97,14 @@ impl BtDaemon {
                        break;
                    }
                }
-                        break;
+                connected_devices.push(dev_info);
                    }
                }
            }
        }
-        let mut lock = state.write().await;
+        let _ = tx.send(BtState {
-        lock.bluetooth = bt_state;
+            adapter_powered,
            devices: connected_devices,
        });
        Ok(())
    }
@@ -100,71 +113,180 @@ impl BtDaemon {
 static PLUGINS: LazyLock<Vec<Box<dyn BtPlugin>>> =
    LazyLock::new(|| vec![Box::new(PixelBudsPlugin)]);
 fn trigger_robust_poll(state: AppReceivers) {
    tokio::spawn(async move {
        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(());
        }
    });
 }
 /// 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 {
-    fn run(
+    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        args: &[&str],
-    ) -> impl std::future::Future<Output = FluxoResult<WaybarOutput>> + Send {
+    ) -> FluxoResult<WaybarOutput> {
-        let action = args.first().cloned().unwrap_or("show").to_string();
+        let action = args.first().cloned().unwrap_or("show");
-        let args = args.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        let bt_state = state.bluetooth.borrow().clone();
        let state = Arc::clone(state);
        let config = config.clone();
-        async move {
+        match action {
-            let bt_state = {
+            "connect" => {
-                let lock = state.read().await;
+                if let Some(mac) = args.get(1) {
-                lock.bluetooth.clone()
+                    if let Ok(session) = bluer::Session::new().await
-            };
+                        && let Ok(adapter) = session.default_adapter().await
-
+                        && let Ok(addr) = mac.parse::<bluer::Address>()
-            match action.as_str() {
+                        && let Ok(device) = adapter.device(addr)
-                "disconnect" if bt_state.connected => {
+                    {
-                    let _ = Command::new("bluetoothctl")
+                        let _ = device.connect().await;
-                        .args(["disconnect", &bt_state.device_address])
+                    }
-                        .output();
+                    trigger_robust_poll(state.clone());
                }
                return Ok(WaybarOutput::default());
            }
-                "cycle_mode" 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) = 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 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());
                            lines.push(format!("PAIRED:{}|{}", alias, addr_str));
                        }
                    }
                }
                return Ok(WaybarOutput {
                    text: lines.join("\n"),
                    ..Default::default()
                });
            }
            "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?;
+                        let modes = p.get_modes(&mac, state).await?;
                    }
                    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![]
                    };
                        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 plugin = PLUGINS.iter().find(|p| {
+                    let target_mac =
-                            p.can_handle(&bt_state.device_alias, &bt_state.device_address)
+                        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(&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(),
@@ -174,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;
@@ -209,10 +332,9 @@ impl WaybarModule for BtModule {
            let text = format_template(format, &tokens);
            let tooltip = format!(
                "{} | MAC: {}\nBattery: {}",
-                    bt_state.device_alias,
+                dev.device_alias,
-                    bt_state.device_address,
+                dev.device_address,
-                    bt_state
+                dev.battery_percentage
                        .battery_percentage
                    .map(|b| format!("{}%", b))
                    .unwrap_or_else(|| "N/A".to_string())
            );
@@ -221,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 {
@@ -232,5 +354,4 @@ impl WaybarModule for BtModule {
            })
        }
    }
    }
 }
@@ -2,8 +2,8 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 pub struct BtrfsModule;
@@ -11,12 +11,12 @@ impl WaybarModule for BtrfsModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let disks = {
-            let s = state.read().await;
+            let s = state.disks.borrow();
-            s.disks.clone()
+            s.clone()
        };
        let mut total_used: f64 = 0.0;
@@ -44,13 +44,7 @@ impl WaybarModule for BtrfsModule {
        let size_gb = total_size / 1024.0 / 1024.0 / 1024.0;
        let percentage = (total_used / total_size) * 100.0;
-        let class = if percentage > 95.0 {
+        let class = classify_usage(percentage, 80.0, 95.0);
            "max"
        } else if percentage > 80.0 {
            "high"
        } else {
            "normal"
        };
        let text = format_template(
            &config.pool.format,
@@ -2,8 +2,8 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 pub struct CpuModule;
@@ -11,16 +11,12 @@ impl WaybarModule for CpuModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let (usage, temp, model) = {
-            let state_lock = state.read().await;
+            let s = state.cpu.borrow();
-            (
+            (s.usage, s.temp, s.model.clone())
                state_lock.cpu.usage,
                state_lock.cpu.temp,
                state_lock.cpu.model.clone(),
            )
        };
        let text = format_template(
@@ -31,13 +27,7 @@ impl WaybarModule for CpuModule {
            ],
        );
-        let class = if usage > 95.0 {
+        let class = classify_usage(usage, 75.0, 95.0);
            "max"
        } else if usage > 75.0 {
            "high"
        } else {
            "normal"
        };
        Ok(WaybarOutput {
            text,
@@ -64,7 +54,7 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
        assert!(output.text.contains("25.0"));
        assert!(output.text.contains("45.0"));
        assert_eq!(output.class.as_deref(), Some("normal"));
@@ -83,7 +73,7 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
        assert_eq!(output.class.as_deref(), Some("high"));
    }
@@ -98,7 +88,7 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
        assert_eq!(output.class.as_deref(), Some("max"));
    }
 }
@@ -2,8 +2,8 @@ use crate::config::Config;
 use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 pub struct DiskModule;
@@ -11,15 +11,19 @@ impl WaybarModule for DiskModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        args: &[&str],
    ) -> Result<WaybarOutput> {
        let mountpoint = args.first().unwrap_or(&"/");
-        let disks = {
+        let disks = state.disks.borrow().clone();
-            let s = state.read().await;
+
-            s.disks.clone()
+        if disks.is_empty() {
-        };
+            return Ok(WaybarOutput {
                text: "Disk Loading...".to_string(),
                ..Default::default()
            });
        }
        for disk in &disks {
            if disk.mount_point == *mountpoint {
@@ -37,13 +41,7 @@ impl WaybarModule for DiskModule {
                    0.0
                };
-                let class = if percentage > 95.0 {
+                let class = classify_usage(percentage, 80.0, 95.0);
                    "max"
                } else if percentage > 80.0 {
                    "high"
                } else {
                    "normal"
                };
                let text = format_template(
                    &config.disk.format,
@@ -76,9 +74,9 @@ impl WaybarModule for DiskModule {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::state::{AppState, DiskInfo, mock_state};
+    use crate::state::{AppState, DiskInfo, MockState, mock_state};
-    fn state_with_disk(mount: &str, total: u64, available: u64) -> crate::state::SharedState {
+    fn state_with_disk(mount: &str, total: u64, available: u64) -> MockState {
        mock_state(AppState {
            disks: vec![DiskInfo {
                mount_point: mount.to_string(),
@@ -95,7 +93,10 @@ mod tests {
        let gb = 1024 * 1024 * 1024;
        let state = state_with_disk("/", 100 * gb, 60 * gb);
        let config = Config::default();
-        let output = DiskModule.run(&config, &state, &["/"]).await.unwrap();
+        let output = DiskModule
            .run(&config, &state.receivers, &["/"])
            .await
            .unwrap();
        assert_eq!(output.class.as_deref(), Some("normal"));
        assert_eq!(output.percentage, Some(40)); // 40% used
    }
@@ -105,15 +106,20 @@ mod tests {
        let gb = 1024 * 1024 * 1024;
        let state = state_with_disk("/", 100 * gb, 15 * gb);
        let config = Config::default();
-        let output = DiskModule.run(&config, &state, &["/"]).await.unwrap();
+        let output = DiskModule
            .run(&config, &state.receivers, &["/"])
            .await
            .unwrap();
        assert_eq!(output.class.as_deref(), Some("high")); // 85% used
    }
    #[tokio::test]
    async fn test_disk_not_found() {
-        let state = mock_state(AppState::default());
+        let state = state_with_disk("/", 100, 50);
        let config = Config::default();
-        let result = DiskModule.run(&config, &state, &["/nonexistent"]).await;
+        let result = DiskModule
            .run(&config, &state.receivers, &["/nonexistent"])
            .await;
        assert!(result.is_err());
    }
 }
@@ -0,0 +1,200 @@
 use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 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::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,
        config: &Config,
        state: &AppReceivers,
        args: &[&str],
    ) -> Result<WaybarOutput> {
        let action = args.first().unwrap_or(&"show");
        if *action == "toggle" {
            let connection =
                Connection::session()
                    .await
                    .map_err(|e| crate::error::FluxoError::Module {
                        module: "dnd",
                        message: format!("DBus connection failed: {}", e),
                    })?;
            // Try SwayNC
            if let Ok(proxy) = SwayncControlProxy::new(&connection).await
                && let Ok(is_dnd) = proxy.dnd().await
            {
                let _ = proxy.set_dnd(!is_dnd).await;
                return Ok(WaybarOutput::default());
            }
            // 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());
            }
            return Err(crate::error::FluxoError::Module {
                module: "dnd",
                message: "No supported notification daemon found to toggle".to_string(),
            });
        }
        let is_dnd = state.dnd.borrow().is_dnd;
        if is_dnd {
            Ok(WaybarOutput {
                text: config.dnd.format_dnd.clone(),
                tooltip: Some("Do Not Disturb: On".to_string()),
                class: Some("dnd".to_string()),
                percentage: None,
            })
        } else {
            Ok(WaybarOutput {
                text: config.dnd.format_normal.clone(),
                tooltip: Some("Do Not Disturb: Off".to_string()),
                class: Some("normal".to_string()),
                percentage: None,
            })
        }
    }
 }
 pub struct DndDaemon;
 #[proxy(
    interface = "org.erikreider.swaync.control",
    default_service = "org.erikreider.swaync.control",
    default_path = "/org/erikreider/swaync/control"
 )]
 trait SwayncControl {
    #[zbus(property)]
    fn dnd(&self) -> zbus::Result<bool>;
    #[zbus(property)]
    fn set_dnd(&self, value: bool) -> zbus::Result<()>;
 }
 impl DndDaemon {
    pub fn new() -> Self {
        Self
    }
    pub fn start(&self, tx: watch::Sender<DndState>) {
        tokio::spawn(async move {
            loop {
                if let Err(e) = Self::listen_loop(&tx).await {
                    error!("DND listener error: {}", e);
                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
                }
            }
        });
    }
    async fn listen_loop(tx: &watch::Sender<DndState>) -> anyhow::Result<()> {
        let connection = Connection::session().await?;
        info!("Connected to D-Bus for DND monitoring");
        // Try SwayNC first (signal-based)
        if let Ok(proxy) = SwayncControlProxy::new(&connection).await
            && let Ok(is_dnd) = proxy.dnd().await
        {
            debug!("Found SwayNC, using signal-based DND monitoring");
            let _ = tx.send(DndState { is_dnd });
            if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
                .destination("org.erikreider.swaync.control")?
                .path("/org/erikreider/swaync/control")?
                .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.erikreider.swaync.control"
                        && let Some(val) = args.changed_properties.get("dnd")
                        && let Ok(is_dnd) = bool::try_from(val)
                    {
                        let _ = tx.send(DndState { is_dnd });
                    }
                }
            }
            return Err(anyhow::anyhow!("SwayNC DND stream ended"));
        }
        // 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 });
                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;
                        }
                    }
                }
                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)"
        ))
    }
 }
@@ -2,11 +2,9 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use anyhow::anyhow;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use std::env;
+use tokio::net::UnixStream;
 use std::io::{Read, Write};
 use std::os::unix::net::UnixStream;
 pub struct GameModule;
@@ -14,10 +12,11 @@ impl WaybarModule for GameModule {
    async fn run(
        &self,
        config: &Config,
-        _state: &SharedState,
+        _state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let is_gamemode = hyprland_ipc("j/getoption animations:enabled")
            .await
            .map(|stdout| stdout.contains("\"int\": 0"))
            .unwrap_or(false);
@@ -39,16 +38,14 @@ impl WaybarModule for GameModule {
    }
 }
-fn hyprland_ipc(cmd: &str) -> Result<String> {
+async fn hyprland_ipc(cmd: &str) -> Result<String> {
-    let signature = env::var("HYPRLAND_INSTANCE_SIGNATURE")
+    let path = crate::utils::get_hyprland_socket(".socket.sock")?;
        .map_err(|_| anyhow!("HYPRLAND_INSTANCE_SIGNATURE not set"))?;
    let path = format!("/tmp/hypr/{}/.socket.sock", signature);
-    let mut stream = UnixStream::connect(path)?;
+    let mut stream = UnixStream::connect(path).await?;
-    stream.write_all(cmd.as_bytes())?;
+    stream.write_all(cmd.as_bytes()).await?;
    let mut response = String::new();
-    stream.read_to_string(&mut response)?;
+    stream.read_to_string(&mut response).await?;
    Ok(response)
 }
@@ -2,8 +2,8 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 pub struct GpuModule;
@@ -11,19 +11,19 @@ impl WaybarModule for GpuModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let (active, vendor, usage, vram_used, vram_total, temp, model) = {
-            let state_lock = state.read().await;
+            let s = state.gpu.borrow();
            (
-                state_lock.gpu.active,
+                s.active,
-                state_lock.gpu.vendor.clone(),
+                s.vendor.clone(),
-                state_lock.gpu.usage,
+                s.usage,
-                state_lock.gpu.vram_used,
+                s.vram_used,
-                state_lock.gpu.vram_total,
+                s.vram_total,
-                state_lock.gpu.temp,
+                s.temp,
-                state_lock.gpu.model.clone(),
+                s.model.clone(),
            )
        };
@@ -36,13 +36,7 @@ impl WaybarModule for GpuModule {
            });
        }
-        let class = if usage > 95.0 {
+        let class = classify_usage(usage, 75.0, 95.0);
            "max"
        } else if usage > 75.0 {
            "high"
        } else {
            "normal"
        };
        let format_str = match vendor.as_str() {
            "Intel" => &config.gpu.format_intel,
@@ -1,5 +1,6 @@
-use crate::state::{DiskInfo, SharedState};
+use crate::state::{CpuState, DiskInfo, GpuState, MemoryState, SysState};
 use sysinfo::{Components, Disks, System};
 use tokio::sync::watch;
 pub struct HardwareDaemon {
    sys: System,
@@ -24,7 +25,12 @@ impl HardwareDaemon {
        }
    }
-    pub async fn poll_fast(&mut self, state: SharedState) {
+    pub async fn poll_fast(
        &mut self,
        cpu_tx: &watch::Sender<CpuState>,
        mem_tx: &watch::Sender<MemoryState>,
        sys_tx: &watch::Sender<SysState>,
    ) {
        self.sys.refresh_cpu_usage();
        self.sys.refresh_memory();
        self.components.refresh(true);
@@ -70,28 +76,37 @@ impl HardwareDaemon {
            }
        }
-        let mut state_lock = state.write().await;
+        let mut cpu = cpu_tx.borrow().clone();
-        state_lock.cpu.usage = cpu_usage as f64;
+        cpu.usage = cpu_usage as f64;
-        state_lock.cpu.temp = cpu_temp;
+        cpu.temp = cpu_temp;
-        state_lock.cpu.model = cpu_model;
+        cpu.model = cpu_model;
        let _ = cpu_tx.send(cpu);
-        state_lock.memory.total_gb = total_mem;
+        let mut mem = mem_tx.borrow().clone();
-        state_lock.memory.used_gb = used_mem;
+        mem.total_gb = total_mem;
        mem.used_gb = used_mem;
        let _ = mem_tx.send(mem);
-        state_lock.sys.load_1 = load_avg.one;
+        let mut sys = sys_tx.borrow().clone();
-        state_lock.sys.load_5 = load_avg.five;
+        sys.load_1 = load_avg.one;
-        state_lock.sys.load_15 = load_avg.fifteen;
+        sys.load_5 = load_avg.five;
-        state_lock.sys.uptime = uptime;
+        sys.load_15 = load_avg.fifteen;
-        state_lock.sys.process_count = process_count;
+        sys.uptime = uptime;
        sys.process_count = process_count;
        let _ = sys_tx.send(sys);
    }
-    pub async fn poll_slow(&mut self, state: SharedState) {
+    pub async fn poll_slow(
        &mut self,
        gpu_tx: &watch::Sender<GpuState>,
        disks_tx: &watch::Sender<Vec<DiskInfo>>,
    ) {
        // 1. Gather GPU data outside of lock
        let mut gpu_state = crate::state::GpuState::default();
        self.gpu_poll_counter = (self.gpu_poll_counter + 1) % 5;
        let should_poll_gpu = self.gpu_poll_counter == 0;
        if should_poll_gpu {
-            self.poll_gpu(&mut gpu_state);
+            self.poll_gpu(&mut gpu_state).await;
        }
        // 2. Gather Disk data outside of lock
@@ -99,6 +114,7 @@ impl HardwareDaemon {
        self.disk_poll_counter = (self.disk_poll_counter + 1) % 10;
        if self.disk_poll_counter == 0 {
            disks_data = Some(
                tokio::task::spawn_blocking(|| {
                    Disks::new_with_refreshed_list()
                        .iter()
                        .map(|d| DiskInfo {
@@ -107,33 +123,70 @@ impl HardwareDaemon {
                            total_bytes: d.total_space(),
                            available_bytes: d.available_space(),
                        })
-                    .collect::<Vec<DiskInfo>>(),
+                        .collect::<Vec<DiskInfo>>()
                })
                .await
                .unwrap_or_default(),
            );
        }
        // 3. Apply to state
        let mut state_lock = state.write().await;
        if should_poll_gpu {
-            state_lock.gpu = gpu_state;
+            let _ = gpu_tx.send(gpu_state);
        }
        if let Some(d) = disks_data {
-            state_lock.disks = d;
+            let _ = disks_tx.send(d);
        }
    }
-    fn poll_gpu(&mut self, gpu: &mut crate::state::GpuState) {
+    async fn poll_gpu(&mut self, gpu: &mut crate::state::GpuState) {
        gpu.active = false;
-        if (self.gpu_vendor.as_deref() == Some("NVIDIA") || self.gpu_vendor.is_none())
+        match self.gpu_vendor.as_deref() {
-            && let Ok(output) = std::process::Command::new("nvidia-smi")
+            Some("NVIDIA") => {
                Self::poll_nvidia(gpu).await;
            }
            Some("AMD") => {
                Self::poll_amd(gpu);
            }
            Some("Intel") => {
                Self::poll_intel(gpu);
            }
            _ => {
                // Detection pass: try each vendor, cache the first that responds.
                Self::poll_nvidia(gpu).await;
                if gpu.active {
                    self.gpu_vendor = Some("NVIDIA".to_string());
                    return;
                }
                Self::poll_amd(gpu);
                if gpu.active {
                    self.gpu_vendor = Some("AMD".to_string());
                    return;
                }
                Self::poll_intel(gpu);
                if gpu.active {
                    self.gpu_vendor = Some("Intel".to_string());
                }
            }
        }
    }
    async fn poll_nvidia(gpu: &mut crate::state::GpuState) {
        let Ok(output) = tokio::process::Command::new("nvidia-smi")
            .args([
                "--query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu,name",
                "--format=csv,noheader,nounits",
            ])
            .output()
-            && output.status.success()
+            .await
-        {
+        else {
            return;
        };
        if !output.status.success() {
            return;
        }
        let stdout = String::from_utf8_lossy(&output.stdout);
        if let Some(line) = stdout.lines().next() {
            let parts: Vec<&str> = line.split(',').collect();
@@ -145,42 +198,30 @@ impl HardwareDaemon {
                gpu.vram_total = parts[2].trim().parse::<f64>().unwrap_or(0.0) / 1024.0;
                gpu.temp = parts[3].trim().parse().unwrap_or(0.0);
                gpu.model = parts[4].trim().to_string();
                    self.gpu_vendor = Some("NVIDIA".to_string());
                    return;
            }
        }
    }
-        if self.gpu_vendor.as_deref() == Some("AMD")
+    fn poll_amd(gpu: &mut crate::state::GpuState) {
            || self.gpu_vendor.as_deref() == Some("Intel")
            || self.gpu_vendor.is_none()
        {
        for i in 0..=3 {
            let base = format!("/sys/class/drm/card{}/device", i);
            let Ok(usage_str) = std::fs::read_to_string(format!("{}/gpu_busy_percent", base))
            else {
                continue;
            };
                if (self.gpu_vendor.as_deref() == Some("AMD") || self.gpu_vendor.is_none())
                    && let Ok(usage_str) =
                        std::fs::read_to_string(format!("{}/gpu_busy_percent", base))
                {
            gpu.active = true;
            gpu.vendor = "AMD".to_string();
            gpu.usage = usage_str.trim().parse().unwrap_or(0.0);
-                    if let Ok(mem_used) =
+            if let Ok(mem_used) = std::fs::read_to_string(format!("{}/mem_info_vram_used", base)) {
-                        std::fs::read_to_string(format!("{}/mem_info_vram_used", base))
+                gpu.vram_used =
-                    {
+                    mem_used.trim().parse::<f64>().unwrap_or(0.0) / 1024.0 / 1024.0 / 1024.0;
                        gpu.vram_used = mem_used.trim().parse::<f64>().unwrap_or(0.0)
                            / 1024.0
                            / 1024.0
                            / 1024.0;
            }
-                    if let Ok(mem_total) =
+            if let Ok(mem_total) = std::fs::read_to_string(format!("{}/mem_info_vram_total", base))
                        std::fs::read_to_string(format!("{}/mem_info_vram_total", base))
            {
-                        gpu.vram_total = mem_total.trim().parse::<f64>().unwrap_or(0.0)
+                gpu.vram_total =
-                            / 1024.0
+                    mem_total.trim().parse::<f64>().unwrap_or(0.0) / 1024.0 / 1024.0 / 1024.0;
                            / 1024.0
                            / 1024.0;
            }
            if let Ok(entries) = std::fs::read_dir(format!("{}/hwmon", base)) {
@@ -193,18 +234,16 @@ impl HardwareDaemon {
                }
            }
            gpu.model = "AMD GPU".to_string();
                    self.gpu_vendor = Some("AMD".to_string());
            return;
        }
    }
-                if self.gpu_vendor.as_deref() == Some("Intel") || self.gpu_vendor.is_none() {
+    fn poll_intel(gpu: &mut crate::state::GpuState) {
-                    let freq_path =
+        for i in 0..=3 {
-                        if std::path::Path::new(&format!("{}/gt_cur_freq_mhz", base)).exists() {
+            let base = format!("/sys/class/drm/card{}/device", i);
            let freq_path = if std::path::Path::new(&format!("{}/gt_cur_freq_mhz", base)).exists() {
                Some(format!("{}/gt_cur_freq_mhz", base))
-                        } else if std::path::Path::new(&format!(
+            } else if std::path::Path::new(&format!("/sys/class/drm/card{}/gt_cur_freq_mhz", i))
                            "/sys/class/drm/card{}/gt_cur_freq_mhz",
                            i
                        ))
                .exists()
            {
                Some(format!("/sys/class/drm/card{}/gt_cur_freq_mhz", i))
@@ -235,11 +274,8 @@ impl HardwareDaemon {
                gpu.vram_used = 0.0;
                gpu.vram_total = 0.0;
                gpu.model = format!("Intel iGPU ({}MHz)", cur_freq);
                        self.gpu_vendor = Some("Intel".to_string());
                return;
            }
        }
    }
        }
    }
 }
@@ -0,0 +1,104 @@
 use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::{AppReceivers, KeyboardState};
 use crate::utils::{TokenValue, format_template};
 use anyhow::anyhow;
 use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::net::UnixStream;
 use tokio::sync::watch;
 use tracing::{error, info};
 pub struct KeyboardModule;
 impl WaybarModule for KeyboardModule {
    async fn run(
        &self,
        config: &Config,
        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let layout = state.keyboard.borrow().layout.clone();
        if layout.is_empty() {
            return Ok(WaybarOutput {
                text: "Layout Loading...".to_string(),
                tooltip: None,
                class: Some("loading".to_string()),
                percentage: None,
            });
        }
        let text = format_template(
            &config.keyboard.format,
            &[("layout", TokenValue::String(layout.clone()))],
        );
        Ok(WaybarOutput {
            text,
            tooltip: Some(format!("Keyboard Layout: {}", layout)),
            class: Some("normal".to_string()),
            percentage: None,
        })
    }
 }
 pub struct KeyboardDaemon;
 impl KeyboardDaemon {
    pub fn new() -> Self {
        Self
    }
    pub fn start(&self, tx: watch::Sender<KeyboardState>) {
        tokio::spawn(async move {
            loop {
                if let Err(e) = Self::listen_loop(&tx).await {
                    error!("Keyboard layout listener error: {}", e);
                    // Fallback to waiting before reconnecting to prevent tight loop
                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
                }
            }
        });
    }
    async fn listen_loop(tx: &watch::Sender<KeyboardState>) -> anyhow::Result<()> {
        let path = crate::utils::get_hyprland_socket(".socket2.sock")?;
        info!("Connecting to Hyprland event socket: {:?}", path);
        let stream = UnixStream::connect(path).await?;
        let reader = BufReader::new(stream);
        let mut lines = reader.lines();
        // Fetch initial layout natively via hyprctl
        if let Ok(output) = tokio::process::Command::new("hyprctl")
            .args(["devices", "-j"])
            .output()
            .await
            && let Ok(json) = serde_json::from_slice::<serde_json::Value>(&output.stdout)
            && let Some(keyboards) = json.get("keyboards").and_then(|v| v.as_array())
            && let Some(main_kb) = keyboards.last()
        {
            // The last active one is usually the main one
            if let Some(layout) = main_kb.get("active_keymap").and_then(|v| v.as_str()) {
                let _ = tx.send(KeyboardState {
                    layout: layout.to_string(),
                });
            }
        }
        while let Ok(Some(line)) = lines.next_line().await {
            if let Some(payload) = line.strip_prefix("activelayout>>") {
                // payload format: keyboard_name,layout_name
                let parts: Vec<&str> = payload.splitn(2, ',').collect();
                if parts.len() == 2 {
                    let layout = parts[1].to_string();
                    let _ = tx.send(KeyboardState { layout });
                }
            }
        }
        Err(anyhow!("Hyprland socket closed or read error"))
    }
 }
@@ -2,8 +2,8 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 pub struct MemoryModule;
@@ -11,12 +11,12 @@ impl WaybarModule for MemoryModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let (used_gb, total_gb) = {
-            let state_lock = state.read().await;
+            let s = state.memory.borrow();
-            (state_lock.memory.used_gb, state_lock.memory.total_gb)
+            (s.used_gb, s.total_gb)
        };
        let ratio = if total_gb > 0.0 {
@@ -33,13 +33,7 @@ impl WaybarModule for MemoryModule {
            ],
        );
-        let class = if ratio > 95.0 {
+        let class = classify_usage(ratio, 75.0, 95.0);
            "max"
        } else if ratio > 75.0 {
            "high"
        } else {
            "normal"
        };
        Ok(WaybarOutput {
            text,
@@ -65,7 +59,10 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
+        let output = MemoryModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert!(output.text.contains("8.00"));
        assert!(output.text.contains("32.00"));
        assert_eq!(output.class.as_deref(), Some("normal"));
@@ -82,7 +79,10 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
+        let output = MemoryModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert_eq!(output.class.as_deref(), Some("high")); // 81%
    }
@@ -96,7 +96,10 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
+        let output = MemoryModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert_eq!(output.class.as_deref(), Some("normal"));
        assert_eq!(output.percentage, Some(0));
    }
@@ -1,26 +1,67 @@
 //! Waybar module implementations.
 //!
 //! Each submodule exposes a [`WaybarModule`] type (CPU, network, audio, …)
 //! and is feature-gated by a `mod-<kind>` flag. The [`WaybarModule`] trait is
 //! what [`crate::registry::dispatch`] uses to evaluate a module on demand.
 //!
 //! Modules come in two flavours:
 //!
 //! * **Watched** — the daemon spawns a background polling/event task that
 //!   pushes state into a `watch::Receiver`, which the module reads lock-free
 //!   (network, cpu, audio, bluetooth, …).
 //! * **Dispatch-only** — evaluated on demand only, without a watch channel
 //!   (power, game, btrfs).
 #[cfg(feature = "mod-audio")]
 pub mod audio;
 #[cfg(feature = "mod-dbus")]
 pub mod backlight;
 #[cfg(feature = "mod-bt")]
 pub mod bt;
 #[cfg(feature = "mod-hardware")]
 pub mod btrfs;
 #[cfg(feature = "mod-hardware")]
 pub mod cpu;
 #[cfg(feature = "mod-hardware")]
 pub mod disk;
 #[cfg(feature = "mod-dbus")]
 pub mod dnd;
 #[cfg(feature = "mod-hardware")]
 pub mod game;
 #[cfg(feature = "mod-hardware")]
 pub mod gpu;
 #[cfg(feature = "mod-hardware")]
 pub mod hardware;
 #[cfg(feature = "mod-dbus")]
 pub mod keyboard;
 #[cfg(feature = "mod-hardware")]
 pub mod memory;
 #[cfg(feature = "mod-dbus")]
 pub mod mpris;
 #[cfg(feature = "mod-network")]
 pub mod network;
 #[cfg(feature = "mod-hardware")]
 pub mod power;
 #[cfg(feature = "mod-hardware")]
 pub mod sys;
 use crate::config::Config;
 use crate::error::Result as FluxoResult;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 /// Common interface implemented by every Waybar module.
 ///
 /// Given the current daemon config, the shared state receivers, and any
 /// caller-supplied arguments, a module produces a single [`WaybarOutput`].
 /// Implementations must be cheap to evaluate — they are invoked on every
 /// client request and on every signaler state change.
 pub trait WaybarModule {
    /// Evaluate the module and return its rendered output.
    fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        args: &[&str],
    ) -> impl std::future::Future<Output = FluxoResult<WaybarOutput>> + Send;
 }
@@ -0,0 +1,341 @@
 use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::{AppReceivers, MprisScrollState, MprisState};
 use crate::utils::{TokenValue, format_template};
 use std::sync::Arc;
 use tokio::sync::{RwLock, watch};
 use tokio::time::Duration;
 use tracing::{debug, info};
 use zbus::{Connection, proxy};
 fn format_mpris_text(format: &str, mpris: &MprisState) -> (String, &'static str) {
    let status_icon = if mpris.is_playing {
        "󰏤"
    } else if mpris.is_paused {
        "󰐊"
    } else {
        "󰓛"
    };
    let class = if mpris.is_playing {
        "playing"
    } else if mpris.is_paused {
        "paused"
    } else {
        "stopped"
    };
    let text = format_template(
        format,
        &[
            ("artist", TokenValue::String(mpris.artist.clone())),
            ("title", TokenValue::String(mpris.title.clone())),
            ("album", TokenValue::String(mpris.album.clone())),
            ("status_icon", TokenValue::String(status_icon.to_string())),
        ],
    );
    (text, class)
 }
 fn apply_scroll_window(full_text: &str, max_len: usize, offset: usize, separator: &str) -> String {
    let char_count = full_text.chars().count();
    let total_len = char_count + separator.chars().count();
    let offset = offset % total_len;
    full_text
        .chars()
        .chain(separator.chars())
        .cycle()
        .skip(offset)
        .take(max_len)
        .collect()
 }
 fn truncate_with_ellipsis(text: &str, max_len: usize) -> String {
    let char_count = text.chars().count();
    if char_count <= max_len {
        return text.to_string();
    }
    let truncated: String = text.chars().take(max_len.saturating_sub(3)).collect();
    format!("{}...", truncated)
 }
 pub struct MprisModule;
 impl WaybarModule for MprisModule {
    async fn run(
        &self,
        config: &Config,
        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let mpris = state.mpris.borrow().clone();
        if mpris.is_stopped && mpris.title.is_empty() {
            return Ok(WaybarOutput {
                text: String::new(),
                tooltip: None,
                class: Some("stopped".to_string()),
                percentage: None,
            });
        }
        let (full_text, class) = format_mpris_text(&config.mpris.format, &mpris);
        let text = if config.mpris.scroll {
            if let Some(max_len) = config.mpris.max_length {
                let scroll = state.mpris_scroll.read().await;
                apply_scroll_window(
                    &full_text,
                    max_len,
                    scroll.offset,
                    &config.mpris.scroll_separator,
                )
            } else {
                full_text.clone()
            }
        } else if let Some(max_len) = config.mpris.max_length {
            truncate_with_ellipsis(&full_text, max_len)
        } else {
            full_text.clone()
        };
        Ok(WaybarOutput {
            text,
            tooltip: Some(format!("{} - {}", mpris.artist, mpris.title)),
            class: Some(class.to_string()),
            percentage: None,
        })
    }
 }
 pub async fn mpris_scroll_ticker(
    config: Arc<RwLock<Config>>,
    mut mpris_rx: watch::Receiver<MprisState>,
    scroll_state: Arc<RwLock<MprisScrollState>>,
    tick_tx: watch::Sender<u64>,
 ) {
    let mut generation: u64 = 0;
    let mut last_track_key = String::new();
    loop {
        let mpris = mpris_rx.borrow_and_update().clone();
        let cfg = config.read().await;
        let scroll_enabled = cfg.mpris.scroll;
        let has_max_length = cfg.mpris.max_length.is_some();
        let scroll_speed = cfg.mpris.scroll_speed;
        let format_str = cfg.mpris.format.clone();
        drop(cfg);
        let (full_text, _) = format_mpris_text(&format_str, &mpris);
        let track_key = format!("{}|{}|{}", mpris.artist, mpris.title, mpris.album);
        if track_key != last_track_key {
            let mut state = scroll_state.write().await;
            state.offset = 0;
            state.full_text = full_text.clone();
            last_track_key = track_key;
            generation += 1;
            let _ = tick_tx.send(generation);
        }
        if scroll_enabled && has_max_length && mpris.is_playing {
            tokio::time::sleep(Duration::from_millis(scroll_speed)).await;
            let mut state = scroll_state.write().await;
            state.offset += 1;
            state.full_text = full_text;
            drop(state);
            generation += 1;
            let _ = tick_tx.send(generation);
            continue;
        }
        // Not scrolling — wait for next state change
        if mpris_rx.changed().await.is_err() {
            break;
        }
    }
 }
 pub struct MprisDaemon;
 #[proxy(
    interface = "org.freedesktop.DBus",
    default_service = "org.freedesktop.DBus",
    default_path = "/org/freedesktop/DBus"
 )]
 trait DBus {
    fn list_names(&self) -> zbus::Result<Vec<String>>;
 }
 #[proxy(
    interface = "org.mpris.MediaPlayer2.Player",
    default_path = "/org/mpris/MediaPlayer2"
 )]
 trait MprisPlayer {
    #[zbus(property)]
    fn playback_status(&self) -> zbus::Result<String>;
    #[zbus(property)]
    fn metadata(
        &self,
    ) -> zbus::Result<std::collections::HashMap<String, zbus::zvariant::Value<'_>>>;
 }
 impl MprisDaemon {
    pub fn new() -> Self {
        Self
    }
    pub fn start(&self, tx: watch::Sender<MprisState>) {
        tokio::spawn(async move {
            loop {
                if let Err(e) = Self::listen_loop(&tx).await {
                    debug!("MPRIS listener ended or error: {}", e);
                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
                }
            }
        });
    }
    async fn listen_loop(tx: &watch::Sender<MprisState>) -> anyhow::Result<()> {
        use futures::StreamExt;
        let connection = Connection::session().await?;
        info!("Connected to D-Bus for MPRIS monitoring");
        let dbus_proxy = DBusProxy::new(&connection).await?;
        loop {
            // Discovery pass: find an active MPRIS player.
            let names = dbus_proxy.list_names().await?;
            let active_player = names
                .into_iter()
                .find(|n| n.starts_with("org.mpris.MediaPlayer2."));
            let Some(player_name) = active_player else {
                send_stopped_if_changed(tx);
                // No player — wait and re-discover.
                tokio::time::sleep(Duration::from_secs(5)).await;
                continue;
            };
            let player_proxy = match MprisPlayerProxy::builder(&connection)
                .destination(player_name.clone())?
                .build()
                .await
            {
                Ok(p) => p,
                Err(_) => {
                    tokio::time::sleep(Duration::from_secs(2)).await;
                    continue;
                }
            };
            // Initial fetch and then signal-driven updates via PropertiesChanged.
            update_from_player(&player_proxy, tx).await;
            let mut status_stream = player_proxy.receive_playback_status_changed().await;
            let mut metadata_stream = player_proxy.receive_metadata_changed().await;
            loop {
                tokio::select! {
                    Some(_) = status_stream.next() => {
                        update_from_player(&player_proxy, tx).await;
                    }
                    Some(_) = metadata_stream.next() => {
                        update_from_player(&player_proxy, tx).await;
                    }
                    _ = tokio::time::sleep(Duration::from_secs(10)) => {
                        // Heartbeat: verify the player is still on the bus.
                        let current = dbus_proxy.list_names().await.unwrap_or_default();
                        if !current.iter().any(|n| n == &player_name) {
                            break;
                        }
                    }
                }
            }
        }
    }
 }
 async fn update_from_player(player: &MprisPlayerProxy<'_>, tx: &watch::Sender<MprisState>) {
    let status = player.playback_status().await.unwrap_or_default();
    let metadata = player.metadata().await.unwrap_or_default();
    let is_playing = status == "Playing";
    let is_paused = status == "Paused";
    let is_stopped = status == "Stopped";
    let (artist, title, album) = parse_metadata(&metadata);
    let current = tx.borrow();
    if current.is_playing != is_playing
        || current.is_paused != is_paused
        || current.is_stopped != is_stopped
        || current.title != title
        || current.artist != artist
        || current.album != album
    {
        drop(current);
        let _ = tx.send(MprisState {
            is_playing,
            is_paused,
            is_stopped,
            artist,
            title,
            album,
        });
    }
 }
 fn parse_metadata(
    metadata: &std::collections::HashMap<String, zbus::zvariant::Value<'_>>,
 ) -> (String, String, String) {
    let mut artist = String::new();
    let mut title = String::new();
    let mut album = String::new();
    if let Some(v) = metadata.get("xesam:artist") {
        if let Ok(arr) = zbus::zvariant::Array::try_from(v) {
            let mut artists = Vec::new();
            for i in 0..arr.len() {
                if let Ok(Some(s)) = arr.get::<&str>(i) {
                    artists.push(s.to_string());
                }
            }
            artist = artists.join(", ");
        } else if let Ok(a) = <&str>::try_from(v) {
            artist = a.to_string();
        }
    }
    if let Some(v) = metadata.get("xesam:title")
        && let Ok(t) = <&str>::try_from(v)
    {
        title = t.to_string();
    }
    if let Some(v) = metadata.get("xesam:album")
        && let Ok(a) = <&str>::try_from(v)
    {
        album = a.to_string();
    }
    (artist, title, album)
 }
 fn send_stopped_if_changed(tx: &watch::Sender<MprisState>) {
    let current = tx.borrow();
    if !current.is_stopped || !current.title.is_empty() {
        drop(current);
        let _ = tx.send(MprisState {
            is_playing: false,
            is_paused: false,
            is_stopped: true,
            artist: String::new(),
            title: String::new(),
            album: String::new(),
        });
    }
 }
@@ -2,11 +2,12 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::{AppReceivers, NetworkState};
 use crate::utils::{TokenValue, format_template};
 use nix::ifaddrs::getifaddrs;
 use std::fs;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::watch;
 pub struct NetworkModule;
@@ -18,6 +19,8 @@ pub struct NetworkDaemon {
    cached_ip: Option<String>,
 }
 type PollResult = crate::error::Result<(String, Option<String>, Option<(u64, u64)>)>;
 impl NetworkDaemon {
    pub fn new() -> Self {
        Self {
@@ -29,28 +32,63 @@ impl NetworkDaemon {
        }
    }
-    pub async fn poll(&mut self, state: SharedState) {
+    pub async fn poll(
-        // Re-detect interface on every poll to catch VPNs or route changes immediately
+        &mut self,
-        if let Ok(iface) = get_primary_interface()
+        state_tx: &watch::Sender<NetworkState>,
-            && !iface.is_empty()
+    ) -> crate::error::Result<()> {
-        {
+        let (iface, ip_opt, bytes_opt) = tokio::task::spawn_blocking(|| -> PollResult {
-            // If the interface changed, or we don't have an IP yet, update the IP
+            let iface = get_primary_interface()?;
            if iface.is_empty() {
                return Ok((String::new(), None, None));
            }
            let ip = get_ip_address(&iface);
            let bytes = get_bytes(&iface).ok();
            Ok((iface, ip, bytes))
        })
        .await
        .map_err(|e| crate::error::FluxoError::System(e.to_string()))??;
        if !iface.is_empty() {
            if self.cached_interface.as_ref() != Some(&iface) || self.cached_ip.is_none() {
-                self.cached_ip = get_ip_address(&iface);
+                self.cached_ip = ip_opt;
-                self.cached_interface = Some(iface);
+                self.cached_interface = Some(iface.clone());
            }
        } else {
            self.cached_interface = None;
            self.cached_ip = None;
            // Provide a default state for "No connection"
            let mut network = state_tx.borrow().clone();
            network.interface.clear();
            network.ip.clear();
            network.rx_mbps = 0.0;
            network.tx_mbps = 0.0;
            let _ = state_tx.send(network);
            return Err(crate::error::FluxoError::Network(
                "No primary interface found".into(),
            ));
        }
-        if let Some(ref interface) = self.cached_interface {
+        let interface = if let Some(ref interface) = self.cached_interface {
            interface.clone()
        } else {
            // No interface detected
            let mut network = state_tx.borrow().clone();
            network.interface.clear();
            network.ip.clear();
            network.rx_mbps = 0.0;
            network.tx_mbps = 0.0;
            let _ = state_tx.send(network);
            return Err(crate::error::FluxoError::Network(
                "Interface disappeared during poll".into(),
            ));
        };
        let time_now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
-            if let Ok((rx_bytes_now, tx_bytes_now)) = get_bytes(interface) {
+        if let Some((rx_bytes_now, tx_bytes_now)) = bytes_opt {
            if self.last_time > 0 && time_now > self.last_time {
                let time_diff = (time_now - self.last_time) as f64;
                let rx_mbps = (rx_bytes_now.saturating_sub(self.last_rx_bytes)) as f64
@@ -62,16 +100,18 @@ impl NetworkDaemon {
                    / 1024.0
                    / 1024.0;
-                    let mut state_lock = state.write().await;
+                let mut network = state_tx.borrow().clone();
-                    state_lock.network.rx_mbps = rx_mbps;
+                network.rx_mbps = rx_mbps;
-                    state_lock.network.tx_mbps = tx_mbps;
+                network.tx_mbps = tx_mbps;
-                    state_lock.network.interface = interface.clone();
+                network.interface = interface.clone();
-                    state_lock.network.ip = self.cached_ip.clone().unwrap_or_default();
+                network.ip = self.cached_ip.clone().unwrap_or_default();
                let _ = state_tx.send(network);
            } else {
                // First poll: no speed data yet, but update interface/ip
-                    let mut state_lock = state.write().await;
+                let mut network = state_tx.borrow().clone();
-                    state_lock.network.interface = interface.clone();
+                network.interface = interface.clone();
-                    state_lock.network.ip = self.cached_ip.clone().unwrap_or_default();
+                network.ip = self.cached_ip.clone().unwrap_or_default();
                let _ = state_tx.send(network);
            }
            self.last_time = time_now;
@@ -80,13 +120,13 @@ impl NetworkDaemon {
        } else {
            // Read failed, might be down
            self.cached_interface = None;
            return Err(crate::error::FluxoError::Network(format!(
                "Failed to read bytes for {}",
                interface
            )));
        }
-        } else {
+
-            // No interface detected
+        Ok(())
            let mut state_lock = state.write().await;
            state_lock.network.interface.clear();
            state_lock.network.ip.clear();
        }
    }
 }
@@ -94,17 +134,12 @@ impl WaybarModule for NetworkModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let (interface, ip, rx_mbps, tx_mbps) = {
-            let s = state.read().await;
+            let s = state.network.borrow();
-            (
+            (s.interface.clone(), s.ip.clone(), s.rx_mbps, s.tx_mbps)
                s.network.interface.clone(),
                s.network.ip.clone(),
                s.network.rx_mbps,
                s.network.tx_mbps,
            )
        };
        if interface.is_empty() {
@@ -148,24 +183,26 @@ impl WaybarModule for NetworkModule {
 }
 fn get_primary_interface() -> Result<String> {
-    let content = fs::read_to_string("/proc/net/route")?;
+    let content = std::fs::read_to_string("/proc/net/route")?;
    let mut defaults = Vec::new();
    for line in content.lines().skip(1) {
        let parts: Vec<&str> = line.split_whitespace().collect();
-        if parts.len() >= 7 {
+        if parts.len() >= 8 {
            let iface = parts[0];
            let dest = parts[1];
            let metric = parts[6].parse::<i32>().unwrap_or(0);
            let mask = u32::from_str_radix(parts[7], 16).unwrap_or(0);
            if dest == "00000000" {
-                defaults.push((metric, iface.to_string()));
+                defaults.push((mask, metric, iface.to_string()));
            }
        }
    }
-    defaults.sort_by_key(|k| k.0);
+    // Sort by mask descending (longest prefix match first), then by metric ascending
-    if let Some((_, dev)) = defaults.first() {
+    defaults.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.cmp(&b.1)));
    if let Some((_, _, dev)) = defaults.first() {
        Ok(dev.clone())
    } else {
        Ok(String::new())
@@ -212,7 +249,10 @@ mod tests {
    async fn test_network_no_connection() {
        let state = mock_state(AppState::default());
        let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert_eq!(output.text, "No connection");
    }
@@ -228,7 +268,10 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert!(output.text.contains("eth0"));
        assert!(output.text.contains("192.168.1.100"));
        assert!(output.text.contains("1.50"));
@@ -247,7 +290,10 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert!(output.text.starts_with("  "));
    }
@@ -263,7 +309,10 @@ mod tests {
            ..Default::default()
        });
        let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
            .run(&config, &state.receivers, &[])
            .await
            .unwrap();
        assert!(output.text.contains("No IP"));
    }
 }
@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 use std::fs;
@@ -12,7 +12,7 @@ impl WaybarModule for PowerModule {
    async fn run(
        &self,
        config: &Config,
-        _state: &SharedState,
+        _state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let critical_threshold = 15;
@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 pub struct SysModule;
@@ -11,17 +11,17 @@ impl WaybarModule for SysModule {
    async fn run(
        &self,
        config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
        _args: &[&str],
    ) -> Result<WaybarOutput> {
        let (load1, load5, load15, uptime_secs, process_count) = {
-            let state_lock = state.read().await;
+            let state_lock = state.sys.borrow();
            (
-                state_lock.sys.load_1,
+                state_lock.load_1,
-                state_lock.sys.load_5,
+                state_lock.load_5,
-                state_lock.sys.load_15,
+                state_lock.load_15,
-                state_lock.sys.uptime,
+                state_lock.uptime,
-                state_lock.sys.process_count,
+                state_lock.process_count,
            )
        };
@@ -1,12 +1,22 @@
-use serde::Serialize;
+//! JSON payload returned to Waybar custom modules.
-#[derive(Serialize, Default)]
+use serde::{Deserialize, Serialize};
 /// A Waybar custom module return value.
 ///
 /// Serialises to the schema Waybar's `return-type: json` expects — the
 /// optional fields are omitted from the output when unset.
 #[derive(Serialize, Deserialize, Clone, Debug, Default)]
 pub struct WaybarOutput {
    /// Primary text shown in the bar.
    pub text: String,
    /// Tooltip text shown on hover.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tooltip: Option<String>,
    /// CSS class applied to the module (for styling).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub class: Option<String>,
    /// Optional 0-100 value usable by bar progress indicators.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub percentage: Option<u8>,
 }
@@ -0,0 +1,85 @@
 //! Central module dispatch: name → [`WaybarModule::run`] lookup.
 //!
 //! The `dispatch` function is called by the IPC request handler with a module
 //! name (e.g. `"cpu"`, `"vol"`) and returns the rendered [`WaybarOutput`]. All
 //! per-module match arms are generated by [`for_each_watched_module!`];
 //! dispatch-only modules without a watch channel (power/game/btrfs) are
 //! listed manually.
 use crate::config::Config;
 use crate::error::{FluxoError, Result as FluxoResult};
 use crate::output::WaybarOutput;
 use crate::state::AppReceivers;
 #[allow(unused_imports)]
 use crate::modules::WaybarModule;
 /// Expands the module registry into a single [`dispatch`] match and a
 /// [`signaler_default_args`] lookup.
 macro_rules! gen_dispatch {
    ($( { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident } )*) => {
        /// Look up a module by name and render its [`WaybarOutput`].
        ///
        /// Returns [`FluxoError::Disabled`] when the module is disabled in
        /// config, and [`FluxoError::Ipc`] when the name is unknown.
        pub async fn dispatch(
            module_name: &str,
            #[allow(unused)] config: &Config,
            #[allow(unused)] state: &AppReceivers,
            #[allow(unused)] args: &[&str],
        ) -> FluxoResult<WaybarOutput> {
            if !config.is_module_enabled(module_name) {
                return Err(FluxoError::Disabled(module_name.to_string()));
            }
            match module_name {
                $(
                    #[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
                        .run(config, state, args)
                        .await
                }
                #[cfg(feature = "mod-hardware")]
                "power" => {
                    crate::modules::power::PowerModule
                        .run(config, state, args)
                        .await
                }
                #[cfg(feature = "mod-hardware")]
                "game" => {
                    crate::modules::game::GameModule
                        .run(config, state, args)
                        .await
                }
                #[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] {
            match module_name {
                $(
                    $($name)|+ => &[$($default_arg),*],
                )*
                "mic" => &["source", "show"],
                _ => &[],
            }
        }
    };
 }
 for_each_watched_module!(gen_dispatch);
@@ -0,0 +1,163 @@
 //! Waybar signalling: watch state channels, send `SIGRTMIN+N` on changes.
 //!
 //! Waybar's custom modules use `signal = N` to rerun their command when they
 //! receive `SIGRTMIN+N`. This task subscribes to every watched module's
 //! `watch::Receiver`, evaluates the module when its channel fires, and only
 //! signals Waybar when the rendered output actually changed. A 50 ms per-signal
 //! debounce prevents storms during rapid state churn.
 use crate::config::Config;
 use crate::state::AppReceivers;
 use std::collections::HashMap;
 use std::sync::Arc;
 use sysinfo::{ProcessesToUpdate, System};
 use tokio::sync::RwLock;
 use tokio::time::{Duration, Instant, sleep};
 use tracing::{debug, warn};
 /// Sends real-time signals to the Waybar process.
 ///
 /// Resolves Waybar's PID lazily and caches it — the PID is invalidated on
 /// signal failure (e.g. Waybar was restarted) and rediscovered via `sysinfo`.
 pub struct WaybarSignaler {
    cached_pid: Option<i32>,
    sys: System,
    last_signal_sent: HashMap<i32, Instant>,
 }
 impl WaybarSignaler {
    /// Create a new signaler with no cached PID.
    pub fn new() -> Self {
        Self {
            cached_pid: None,
            sys: System::new(),
            last_signal_sent: HashMap::new(),
        }
    }
    fn find_waybar_pid(&mut self) -> Option<i32> {
        self.sys.refresh_processes(ProcessesToUpdate::All, true);
        for (pid, process) in self.sys.processes() {
            if process.name() == "waybar" {
                return Some(pid.as_u32() as i32);
            }
        }
        None
    }
    fn send_signal(&mut self, signal_num: i32) {
        if let Some(last) = self.last_signal_sent.get(&signal_num)
            && last.elapsed() < Duration::from_millis(50)
        {
            return;
        }
        let mut valid_pid = false;
        if let Some(pid) = self.cached_pid
            && unsafe { libc::kill(pid, 0) } == 0
        {
            valid_pid = true;
        }
        if !valid_pid {
            self.cached_pid = self.find_waybar_pid();
        }
        if let Some(pid) = self.cached_pid {
            let sig = libc::SIGRTMIN() + signal_num;
            if unsafe { libc::kill(pid, sig) } == 0 {
                debug!("Sent SIGRTMIN+{} to waybar (PID: {})", signal_num, pid);
                self.last_signal_sent.insert(signal_num, Instant::now());
            } else {
                warn!("Failed to send SIGRTMIN+{} to waybar", signal_num);
                self.cached_pid = None;
            }
        } else {
            debug!("Waybar process not found, skipping signal.");
        }
    }
 }
 /// Generates [`WaybarSignaler::run`] from the central module registry.
 ///
 /// For each watched module we emit:
 /// * a cfg-gated `watch::Receiver::changed()` future (or `pending::<()>` when
 ///   the feature is disabled, so the `tokio::select!` arm compiles uniformly),
 /// * a `select!` arm that re-evaluates the module and signals Waybar once per
 ///   changed output.
 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 {
            /// Run the signaler event loop forever.
            ///
            /// Consumes `self`; intended to be spawned as a long-lived task.
            pub async fn run(mut self, config_lock: Arc<RwLock<Config>>, mut receivers: AppReceivers) {
                let mut last_outputs: HashMap<&'static str, String> = HashMap::new();
                loop {
                    let signals = config_lock.read().await.signals.clone();
                    macro_rules! check_and_signal {
                        ($module_name:expr, $signal_opt:expr) => {
                            if let Some(sig) = $signal_opt {
                                let config = config_lock.read().await;
                                if let Some(out) = crate::daemon::evaluate_module_for_signaler(
                                    $module_name,
                                    &receivers,
                                    &config,
                                )
                                .await
                                {
                                    if last_outputs.get($module_name) != Some(&out) {
                                        last_outputs.insert($module_name, out);
                                        self.send_signal(sig);
                                    }
                                }
                            }
                        };
                    }
                    // 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 = $feature)]
                        let $field = receivers.$field.changed();
                    )*
                    // MPRIS scroll tick (special case — not a watched module)
                    #[cfg(not(feature = "mod-dbus"))]
                    let mpris_scroll_tick = std::future::pending::<
                        std::result::Result<(), tokio::sync::watch::error::RecvError>,
                    >();
                    #[cfg(feature = "mod-dbus")]
                    let mpris_scroll_tick = receivers.mpris_scroll_tick.changed();
                    tokio::select! {
                        $(
                            res = $field, if signals.$signal.is_some() => {
                                if res.is_ok() {
                                    $(check_and_signal!($sig_name, signals.$signal);)+
                                }
                            }
                        )*
                        // 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)) => {
                            // heartbeat: re-read signals config on each iteration
                        }
                    }
                }
            }
        }
    };
 }
 for_each_watched_module!(gen_signaler_run);
@@ -1,60 +1,108 @@
 //! Shared state types exchanged between daemon tasks and modules.
 //!
 //! Every "watched" module has a `watch::Receiver<StateType>` held by
 //! [`AppReceivers`]; background tasks write into the paired sender. Readers
 //! (the request handler, the signaler) take a cheap snapshot via
 //! `Receiver::borrow()` and render their output from it.
 use crate::output::WaybarOutput;
 use std::collections::HashMap;
 use std::sync::Arc;
-use tokio::sync::RwLock;
+use tokio::sync::{RwLock, mpsc, watch};
 use tokio::time::Instant;
-#[derive(Default, Clone)]
+/// Generates the [`AppReceivers`] struct, with one `watch::Receiver` field
-pub struct AppState {
+/// per watched module (cfg-gated by feature flag).
-    pub network: NetworkState,
+macro_rules! gen_app_receivers {
-    pub cpu: CpuState,
+    ($( { $feature:literal, $field:ident, $state:ty, [$($name:literal),+], [$($sig_name:literal),+], $module:path, $signal:ident, [$($default_arg:literal),*], $config:ident } )*) => {
-    pub memory: MemoryState,
+        /// Bundle of every watch-channel receiver and control-channel handle.
-    pub sys: SysState,
+        ///
-    pub gpu: GpuState,
+        /// Cloned into each IPC request handler and each module daemon so that
-    pub disks: Vec<DiskInfo>,
+        /// they can snapshot state without locking. Per-module receivers are
-    pub bluetooth: BtState,
+        /// generated from [`for_each_watched_module!`]; the remaining fields
-    pub audio: AudioState,
+        /// (`health`, `bt_cycle`, `audio_cmd_tx`, `mpris_scroll_*`) are shared
-    pub health: HashMap<String, ModuleHealth>,
+        /// control state.
        #[derive(Clone)]
        pub struct AppReceivers {
            $(
                #[cfg(feature = $feature)]
                pub $field: watch::Receiver<$state>,
            )*
            #[cfg(feature = "mod-bt")]
            pub bt_cycle: Arc<RwLock<usize>>,
            #[cfg(feature = "mod-dbus")]
            pub mpris_scroll: Arc<RwLock<MprisScrollState>>,
            #[cfg(feature = "mod-dbus")]
            pub mpris_scroll_tick: watch::Receiver<u64>,
            pub health: Arc<RwLock<HashMap<String, ModuleHealth>>>,
            #[cfg(feature = "mod-bt")]
            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);
 /// Runtime health statistics used for backoff decisions.
 #[derive(Clone, Default)]
 pub struct ModuleHealth {
    pub consecutive_failures: u32,
    pub last_failure: Option<Instant>,
    pub backoff_until: Option<Instant>,
    pub last_successful_output: Option<WaybarOutput>,
 }
 /// Current default audio sink + source plus all available devices.
 #[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>,
 }
 /// Metadata for one PulseAudio sink or source.
 #[derive(Default, Clone)]
 pub struct AudioDeviceInfo {
    pub name: String,
    pub description: String,
    pub volume: u8,
    pub muted: bool,
    pub channels: u8,
 }
 /// A single BlueZ device, optionally annotated by a plugin (buds, maestro…).
 #[derive(Default, Clone)]
-pub struct AudioSourceInfo {
+pub struct BtDeviceInfo {
    pub name: String,
    pub description: String,
    pub volume: u8,
    pub muted: bool,
 }
 #[derive(Default, Clone)]
 pub struct BtState {
    pub connected: bool,
    pub adapter_powered: bool,
    pub device_alias: String,
    pub device_address: String,
    pub battery_percentage: Option<u8>,
    pub plugin_data: Vec<(String, String)>,
 }
 /// Snapshot of the Bluetooth adapter plus every tracked device.
 #[derive(Default, Clone)]
 pub struct BtState {
    pub adapter_powered: bool,
    pub devices: Vec<BtDeviceInfo>,
 }
 impl BtState {
    /// Return the device the client is currently cycled to, if any.
    ///
    /// The `index` is taken modulo `devices.len()` so cycling past the end
    /// wraps around naturally.
    pub fn active_device(&self, index: usize) -> Option<&BtDeviceInfo> {
        if self.devices.is_empty() {
            None
        } else {
            Some(&self.devices[index % self.devices.len()])
        }
    }
 }
 /// Per-mountpoint disk usage.
 #[derive(Default, Clone)]
 pub struct DiskInfo {
    pub mount_point: String,
@@ -63,6 +111,7 @@ pub struct DiskInfo {
    pub available_bytes: u64,
 }
 /// Throughput and identity of the active network interface.
 #[derive(Default, Clone)]
 pub struct NetworkState {
    pub rx_mbps: f64,
@@ -71,6 +120,7 @@ pub struct NetworkState {
    pub ip: String,
 }
 /// CPU utilisation and temperature.
 #[derive(Clone)]
 pub struct CpuState {
    pub usage: f64,
@@ -88,12 +138,14 @@ impl Default for CpuState {
    }
 }
 /// RAM usage in gigabytes.
 #[derive(Default, Clone)]
 pub struct MemoryState {
    pub used_gb: f64,
    pub total_gb: f64,
 }
 /// Load averages, uptime, and process count.
 #[derive(Default, Clone)]
 pub struct SysState {
    pub load_1: f64,
@@ -103,6 +155,9 @@ pub struct SysState {
    pub process_count: usize,
 }
 /// GPU snapshot (vendor-agnostic).
 ///
 /// `active` is `false` until detection finds a supported GPU.
 #[derive(Clone)]
 pub struct GpuState {
    pub active: bool,
@@ -128,9 +183,202 @@ impl Default for GpuState {
    }
 }
-pub type SharedState = Arc<RwLock<AppState>>;
+/// Do-Not-Disturb toggle state.
-
+#[derive(Default, Clone)]
-#[cfg(test)]
+pub struct DndState {
-pub fn mock_state(state: AppState) -> SharedState {
+    pub is_dnd: bool,
-    Arc::new(RwLock::new(state))
+}
 /// Currently active keyboard layout.
 #[derive(Default, Clone)]
 pub struct KeyboardState {
    pub layout: String,
 }
 /// Display backlight brightness as a 0-100 percentage.
 #[derive(Default, Clone)]
 pub struct BacklightState {
    pub percentage: u8,
 }
 /// Marquee scroll position for the MPRIS module.
 #[derive(Default, Clone)]
 pub struct MprisScrollState {
    pub offset: usize,
    pub full_text: String,
 }
 /// Currently playing media metadata from an MPRIS player.
 #[derive(Default, Clone)]
 pub struct MprisState {
    pub is_playing: bool,
    pub is_paused: bool,
    pub is_stopped: bool,
    pub artist: String,
    pub title: String,
    pub album: String,
 }
 /// Test harness holding a synthetic [`AppReceivers`] plus its senders.
 ///
 /// The senders are kept alive via `_*_tx` fields so test code can drive the
 /// watch channels without them being dropped.
 #[cfg(test)]
 pub struct MockState {
    pub receivers: AppReceivers,
    #[cfg(feature = "mod-network")]
    _net_tx: watch::Sender<NetworkState>,
    #[cfg(feature = "mod-hardware")]
    _cpu_tx: watch::Sender<CpuState>,
    #[cfg(feature = "mod-hardware")]
    _mem_tx: watch::Sender<MemoryState>,
    #[cfg(feature = "mod-hardware")]
    _sys_tx: watch::Sender<SysState>,
    #[cfg(feature = "mod-hardware")]
    _gpu_tx: watch::Sender<GpuState>,
    #[cfg(feature = "mod-hardware")]
    _disks_tx: watch::Sender<Vec<DiskInfo>>,
    #[cfg(feature = "mod-bt")]
    _bt_tx: watch::Sender<BtState>,
    #[cfg(feature = "mod-audio")]
    _audio_tx: watch::Sender<AudioState>,
    #[cfg(feature = "mod-dbus")]
    _mpris_tx: watch::Sender<MprisState>,
    #[cfg(feature = "mod-dbus")]
    _backlight_tx: watch::Sender<BacklightState>,
    #[cfg(feature = "mod-dbus")]
    _keyboard_tx: watch::Sender<KeyboardState>,
    #[cfg(feature = "mod-dbus")]
    _dnd_tx: watch::Sender<DndState>,
 }
 /// Plain-data counterpart of [`AppReceivers`] used to seed a [`MockState`].
 #[cfg(test)]
 #[derive(Default, Clone)]
 pub struct AppState {
    #[cfg(feature = "mod-network")]
    pub network: NetworkState,
    #[cfg(feature = "mod-hardware")]
    pub cpu: CpuState,
    #[cfg(feature = "mod-hardware")]
    pub memory: MemoryState,
    #[cfg(feature = "mod-hardware")]
    pub sys: SysState,
    #[cfg(feature = "mod-hardware")]
    pub gpu: GpuState,
    #[cfg(feature = "mod-hardware")]
    pub disks: Vec<DiskInfo>,
    #[cfg(feature = "mod-bt")]
    pub bluetooth: BtState,
    #[cfg(feature = "mod-audio")]
    pub audio: AudioState,
    #[cfg(feature = "mod-dbus")]
    pub mpris: MprisState,
    #[cfg(feature = "mod-dbus")]
    pub backlight: BacklightState,
    #[cfg(feature = "mod-dbus")]
    pub keyboard: KeyboardState,
    #[cfg(feature = "mod-dbus")]
    pub dnd: DndState,
    pub health: HashMap<String, ModuleHealth>,
 }
 /// Build a [`MockState`] from a plain [`AppState`] snapshot for unit tests.
 #[cfg(test)]
 pub fn mock_state(state: AppState) -> MockState {
    #[cfg(feature = "mod-network")]
    let (net_tx, net_rx) = watch::channel(state.network);
    #[cfg(feature = "mod-hardware")]
    let (cpu_tx, cpu_rx) = watch::channel(state.cpu);
    #[cfg(feature = "mod-hardware")]
    let (mem_tx, mem_rx) = watch::channel(state.memory);
    #[cfg(feature = "mod-hardware")]
    let (sys_tx, sys_rx) = watch::channel(state.sys);
    #[cfg(feature = "mod-hardware")]
    let (gpu_tx, gpu_rx) = watch::channel(state.gpu);
    #[cfg(feature = "mod-hardware")]
    let (disks_tx, disks_rx) = watch::channel(state.disks);
    #[cfg(feature = "mod-bt")]
    let (bt_tx, bt_rx) = watch::channel(state.bluetooth);
    #[cfg(feature = "mod-audio")]
    let (audio_tx, audio_rx) = watch::channel(state.audio);
    #[cfg(feature = "mod-dbus")]
    let (mpris_tx, mpris_rx) = watch::channel(state.mpris);
    #[cfg(feature = "mod-dbus")]
    let (backlight_tx, backlight_rx) = watch::channel(state.backlight);
    #[cfg(feature = "mod-dbus")]
    let (keyboard_tx, keyboard_rx) = watch::channel(state.keyboard);
    #[cfg(feature = "mod-dbus")]
    let (dnd_tx, dnd_rx) = watch::channel(state.dnd);
    #[cfg(feature = "mod-bt")]
    let (bt_force_tx, _) = mpsc::channel(1);
    #[cfg(feature = "mod-audio")]
    let (audio_cmd_tx, _) = mpsc::channel(1);
    MockState {
        receivers: AppReceivers {
            #[cfg(feature = "mod-network")]
            network: net_rx,
            #[cfg(feature = "mod-hardware")]
            cpu: cpu_rx,
            #[cfg(feature = "mod-hardware")]
            memory: mem_rx,
            #[cfg(feature = "mod-hardware")]
            sys: sys_rx,
            #[cfg(feature = "mod-hardware")]
            gpu: gpu_rx,
            #[cfg(feature = "mod-hardware")]
            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")]
            mpris: mpris_rx,
            #[cfg(feature = "mod-dbus")]
            backlight: backlight_rx,
            #[cfg(feature = "mod-dbus")]
            keyboard: keyboard_rx,
            #[cfg(feature = "mod-dbus")]
            dnd: dnd_rx,
            #[cfg(feature = "mod-dbus")]
            mpris_scroll: Arc::new(RwLock::new(MprisScrollState::default())),
            #[cfg(feature = "mod-dbus")]
            mpris_scroll_tick: {
                let (_, rx) = watch::channel(0u64);
                rx
            },
            health: Arc::new(RwLock::new(state.health)),
            #[cfg(feature = "mod-bt")]
            bt_force_poll: bt_force_tx,
            #[cfg(feature = "mod-audio")]
            audio_cmd_tx,
        },
        #[cfg(feature = "mod-network")]
        _net_tx: net_tx,
        #[cfg(feature = "mod-hardware")]
        _cpu_tx: cpu_tx,
        #[cfg(feature = "mod-hardware")]
        _mem_tx: mem_tx,
        #[cfg(feature = "mod-hardware")]
        _sys_tx: sys_tx,
        #[cfg(feature = "mod-hardware")]
        _gpu_tx: gpu_tx,
        #[cfg(feature = "mod-hardware")]
        _disks_tx: disks_tx,
        #[cfg(feature = "mod-bt")]
        _bt_tx: bt_tx,
        #[cfg(feature = "mod-audio")]
        _audio_tx: audio_tx,
        #[cfg(feature = "mod-dbus")]
        _mpris_tx: mpris_tx,
        #[cfg(feature = "mod-dbus")]
        _backlight_tx: backlight_tx,
        #[cfg(feature = "mod-dbus")]
        _keyboard_tx: keyboard_tx,
        #[cfg(feature = "mod-dbus")]
        _dnd_tx: dnd_tx,
    }
 }
@@ -1,19 +1,31 @@
 //! Shared helpers: menu spawning, Hyprland socket lookup, and template formatting.
 use anyhow::{Context, Result};
 use std::io::Write;
 use std::process::{Command, Stdio};
 /// Pipe `items` into an external menu program (rofi/dmenu/wofi) and return
 /// the user's selection.
 ///
 /// The prompt is exposed to the command as `$FLUXO_PROMPT` (preferred) and
 /// as a legacy `{prompt}` placeholder that is substituted in the shell string.
 pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<String> {
    let cmd_str = menu_cmd.replace("{prompt}", prompt);
    let mut child = Command::new("sh")
        .arg("-c")
        .arg(&cmd_str)
        .env("FLUXO_PROMPT", prompt)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        // Suppress GTK/Wayland noise from tools like wofi.
        .stderr(Stdio::null())
        .spawn()
        .context("Failed to spawn menu command")?;
    if let Some(mut stdin) = child.stdin.take() {
-        let input = items.join("\n");
+        let mut input = items.join("\n");
        // Trailing newline is required by wofi/rofi.
        input.push('\n');
        stdin
            .write_all(input.as_bytes())
            .context("Failed to write to menu stdin")?;
@@ -33,24 +45,74 @@ pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<Strin
    Ok(selected)
 }
 /// Resolve the path to a Hyprland IPC socket for the current session.
 ///
 /// Looks under `$XDG_RUNTIME_DIR/hypr/$HYPRLAND_INSTANCE_SIGNATURE/` first,
 /// then falls back to `/tmp/hypr/...` for older Hyprland builds.
 pub fn get_hyprland_socket(socket_name: &str) -> Result<std::path::PathBuf> {
    let signature = std::env::var("HYPRLAND_INSTANCE_SIGNATURE")
        .context("HYPRLAND_INSTANCE_SIGNATURE not set")?;
    if let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") {
        let path = std::path::PathBuf::from(runtime_dir)
            .join("hypr")
            .join(&signature)
            .join(socket_name);
        if path.exists() {
            return Ok(path);
        }
    }
    let path = std::path::PathBuf::from("/tmp/hypr")
        .join(&signature)
        .join(socket_name);
    if path.exists() {
        Ok(path)
    } else {
        Err(anyhow::anyhow!(
            "Hyprland socket {} not found in runtime dir or /tmp",
            socket_name
        ))
    }
 }
 use regex::Regex;
 use std::sync::LazyLock;
 /// Bucket `value` into `"normal"`, `"high"`, or `"max"` for CSS class output.
 pub fn classify_usage(value: f64, high: f64, max: f64) -> &'static str {
    if value > max {
        "max"
    } else if value > high {
        "high"
    } else {
        "normal"
    }
 }
 /// A typed value supplied to [`format_template`] — chosen at call site so
 /// formatting handles precision and alignment correctly per type.
 pub enum TokenValue {
    Float(f64),
    Int(i64),
    String(String),
 }
 /// Token grammar: `{name}`, `{name:>5}`, `{name:<8.2}`, `{name:^6}`, etc.
 pub static TOKEN_RE: LazyLock<Regex> =
    LazyLock::new(|| Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap());
 /// Substitute `{name[:align[width[.precision]]]}` tokens in a template string.
 ///
 /// Unknown tokens are left verbatim. Width/alignment/precision follow Rust's
 /// `std::fmt` semantics (`<` left, `^` center, `>` right).
 pub fn format_template<K>(template: &str, values: &[(K, TokenValue)]) -> String
 where
    K: AsRef<str>,
 {
-    static RE: LazyLock<Regex> = LazyLock::new(|| {
+    TOKEN_RE
-        Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap()
+        .replace_all(template, |caps: &regex::Captures| {
    });
    RE.replace_all(template, |caps: &regex::Captures| {
            let name = &caps[1];
            if let Some((_, val)) = values.iter().find(|(k, _)| k.as_ref() == name) {
                let align = caps.get(2).map(|m| m.as_str()).unwrap_or(">");
Author	SHA1	Message	Date
nvrl	f89833a62e	missing docs Release / Build and Release (push) Successful in 2m54s Details	2026-04-05 11:56:58 +02:00
nvrl	198986efac	cleanup of gpu and config gen	2026-04-05 11:42:08 +02:00
nvrl	d1178ff8ba	implemented signals for mpris	2026-04-05 11:40:31 +02:00
nvrl	5c5d0148f8	removed callback patterns Release / Build and Release (push) Successful in 22s Details	2026-04-05 11:38:14 +02:00
nvrl	fdfd54b518	central registry	2026-04-05 11:35:57 +02:00
nvrl	708317a10b	daemon decomposition	2026-04-04 18:39:15 +02:00
nvrl	f1e601f9ed	poll abstraction	2026-04-04 18:37:27 +02:00
nvrl	57906de920	redesign bt module/menu Release / Build and Release (push) Successful in 2m55s Details	2026-04-04 14:43:35 +02:00
nvrl	2050c345f1	feature/scroll-animation Release / Build and Release (push) Successful in 2m50s Details	2026-04-04 05:11:04 +02:00
nvrl	75601305e2	version bump Release / Build and Release (push) Successful in 2m47s Details	2026-04-04 04:25:04 +02:00
nvrl	52cc041c42	clippy	2026-04-04 04:24:35 +02:00
nvrl	cb8b641447	implemented 'enabled'	2026-04-04 04:24:09 +02:00
nvrl	071d973fea	version bump Release / Build and Release (push) Successful in 2m53s Details	2026-04-04 00:18:50 +02:00
nvrl	31072bc645	refactor + feature flags Release / Build and Release (push) Has been cancelled Details	2026-04-04 00:18:22 +02:00
nvrl	941942d550	fixed dnd	2026-04-03 23:45:58 +02:00
nvrl	492f0787cb	WIP: version bump Release / Build and Release (push) Failing after 2m43s Details	2026-04-03 15:16:27 +02:00
nvrl	718d3f99e9	version bump Release / Build and Release (push) Failing after 22s Details	2026-04-03 15:15:13 +02:00
nvrl	b2e8d5fc1b	updated docu	2026-04-03 15:14:49 +02:00
nvrl	2572928195	Merge pull request 'feature/events' (#2 ) from feature/events into main Release / Build and Release (push) Successful in 21s Details Reviewed-on: #2	2026-04-03 15:02:09 +02:00
nvrl	25ecde96fa	clippy CI / Lint and Test (pull_request) Failing after 1m31s Details CI / Version Check (pull_request) Failing after 3s Details	2026-04-03 15:01:23 +02:00
nvrl	16d12e6dce	implemented signal based daemon and dbus events + mpris/dnd/keyboard module	2026-04-03 15:00:58 +02:00
nvrl	d28e51de6d	version bupm Release / Build and Release (push) Successful in 2m10s Details	2026-04-02 18:46:33 +02:00
nvrl	b18af49ac8	graceful shutdown Release / Build and Release (push) Has been cancelled Details	2026-04-02 18:46:17 +02:00
nvrl	0617e53412	version bump Release / Build and Release (push) Successful in 2m8s Details	2026-04-02 18:11:47 +02:00
nvrl	bdbd6a8a40	added tokio shared states instead of monolithic state Release / Build and Release (push) Has been cancelled Details	2026-04-02 18:11:21 +02:00