mod cloud;
 mod config;
 mod icons;
 mod listeners;
 mod modules;
 mod osd;
 mod stats;
 mod tray;
 
 // Re-export at the crate root so call sites (here and in modules.rs) keep
 // their pre-split names.
 pub(crate) use cloud::*;
 pub(crate) use config::*;
 pub(crate) use listeners::*;
 pub(crate) use stats::*;
 pub(crate) use tray::*;
 
 use cce_ui::scene::paint::DropletFinish;
 use modules::{StatusModule, WindowModule, ClockModule, BatteryModule, VolumeModule, BrightnessModule, MemoryModule, CpuModule, WifiModule, StatsModule, TrayModule, LightSourceModule};
 
 use std::collections::HashMap;
 use cce_ui::cosmic_text::{
     Attrs, Buffer, FontSystem, Metrics,
 };
 use cce_ui::color;
 use cce_ui::widget::{WidgetHost, MouseButton, ElementState, MouseScrollDelta, KeyEvent, WidgetHostExt};
 
 #[derive(Debug, Clone)]
 pub struct TrayPixmap {
     pub width: i32,
     pub height: i32,
     pub pixels: Vec<u8>,
 }
 
 #[allow(dead_code)]
 #[derive(Debug, Clone)]
 pub struct TrayItem {
     pub id: String,
     pub icon_name: Option<String>,
     pub icon_theme_path: Option<String>,
     pub pixmaps: Option<Vec<TrayPixmap>>,
     pub title: Option<String>,
     pub dbus_id: Option<String>,
 }
 
 #[derive(Debug, Clone)]
 pub struct TrayIconBounds {
     pub id: String,
     pub x: f32,
     pub y: f32,
     pub w: f32,
     pub h: f32,
     pub title: Option<String>,
     pub dbus_id: Option<String>,
 }
 
 #[derive(Debug, Clone)]
 pub struct SystemStats {
     pub clock: String,
     /// Memory in use as a whole percentage of the total; `None` when
     /// /proc/meminfo is unreadable.
     pub memory: Option<u8>,
     /// CPU busy share as a whole percentage; `None` when /proc/stat is
     /// unreadable.
     pub cpu_pct: Option<u8>,
     /// `(capacity %, charging)`; `None` on a machine without a battery.
     pub battery: Option<(i32, bool)>,
     /// `(level %, muted)`; `None` when pactl is unavailable. The level is
     /// `None` when pactl answered but reported no percentage.
     pub volume: Option<(Option<u32>, bool)>,
     /// Backlight level as a whole percentage; `None` without a backlight.
     pub brightness: Option<i32>,
     /// `(signal %, connected)`; `None` without a wireless interface. The
     /// signal is `None` while disconnected.
     pub wifi: Option<(Option<u8>, bool)>,
 }
 
 /// A bundled cce-icons glyph placed in the bar: `image` is the tinted
 /// texture from `icons::glyph`, the rect is logical px, `alpha` the
 /// ghosting under a superimposed readout. Retained like `text_prims` and
 /// replayed by `display_list`, drawn before the text so the number sits on
 /// the glyph.
 #[derive(Debug, Clone, Copy)]
 pub struct IconPrim {
     pub image: u32,
     pub x: f32,
     pub y: f32,
     pub w: f32,
     pub h: f32,
     pub alpha: f32,
 }
 
 /// The subset of [`SystemStats`] a given module actually paints, as a comparable
 /// signature. The stats poller pushes a full `SystemStatsUpdated` every second
 /// regardless of change; deduping on this signature lets a module skip the redraw
 /// (and the compositor's whole-backdrop blur re-bake it triggers) when its own value
 /// is unchanged — e.g. the clock shows HH:MM and only changes once a minute.
 /// `None` means the module ignores stats entirely (window/tray/light_source), so a
 /// stats push never redraws it. Unknown / combined-bar modules compare everything.
 fn stats_signature(module: Option<&str>, s: &SystemStats) -> Option<String> {
     match module {
         Some("clock") => Some(s.clock.clone()),
         Some("cpu") => Some(format!("{:?}", s.cpu_pct)),
         Some("memory") => Some(format!("{:?}", s.memory)),
         Some("battery") => Some(format!("{:?}", s.battery)),
         Some("volume") => Some(format!("{:?}", s.volume)),
         Some("brightness") => Some(format!("{:?}", s.brightness)),
         Some("wifi") => Some(format!("{:?}", s.wifi)),
         Some("window") | Some("tray") | Some("light_source") => None,
         // `stats` paints every reader's value; so does an unknown name.
         _ => Some(format!(
             "{}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}",
             s.clock, s.memory, s.cpu_pct, s.battery, s.volume, s.brightness, s.wifi
         )),
     }
 }
 
 /// Does this module run the brightness/volume fast path
 /// ([`spawn_level_watchers`])? Then it owns those two values, and the
 /// one-second poll leaves them alone.
 fn has_fast_levels(module: Option<&str>) -> bool {
     paints_stat(module, "brightness") || paints_stat(module, "volume")
 }
 
 /// Does this module paint `field` (`"brightness"` or `"volume"`)? The
 /// fast-path pushes carry one value each, so they ask this where a full stats
 /// push compares a [`stats_signature`]; the two must agree about which
 /// modules are blind to a stat, or a segment would redraw for a number it
 /// does not show.
 fn paints_stat(module: Option<&str>, field: &str) -> bool {
     match module {
         // The other single-stat modules; stats-blind modules.
         Some("clock") | Some("cpu") | Some("memory") | Some("battery") | Some("wifi") => false,
         Some("window") | Some("tray") | Some("light_source") => false,
         Some("brightness") => field == "brightness",
         Some("volume") => field == "volume",
         // `stats` paints every reader's value; so does an unknown name.
         _ => true,
     }
 }
 
 #[derive(Debug, Clone)]
 pub(crate) enum CustomEvent {
     LayoutUpdated(String),
     TitleUpdated(String),
     SystemStatsUpdated(SystemStats),
     /// The backlight moved, pushed by the fast path (`watch_brightness`) the
     /// moment it did rather than at the next one-second stats poll.
     BrightnessUpdated(Option<i32>),
     /// The default sink's `(level %, muted)` moved, pushed by the fast path
     /// (`watch_volume`) on the sound server's own event.
     VolumeUpdated(Option<(Option<u32>, bool)>),
     TrayUpdated(TrayItem),
     TrayRemoved(String),
     /// A bar-built in-surface menu (window picker), fetched off-thread.
     MenuReady { title: String, pages: Vec<MenuPage>, min_w: f32 },
     SwitcherTriggered,
     /// Compositor click-away-close: a pointer press landed somewhere other
     /// than this expanded segment. Payload = the pressed segment's app_id
     /// ("-" for none); a segment ignores a dismiss naming itself.
     MenuDismiss(String),
     /// A tray icon's DBusMenu, fetched and flattened for the in-surface menu.
     TrayMenuFetched { destination: String, menu_path: String, pages: Vec<MenuPage> },
     ToggleHideModules,
     ToggleAdjustPositionMode,
 }
 
 /// A droplet spec whose shape knobs resolve against `reference_h` instead of
 /// the box they are given, for a box that is actually `box_h` tall.
 ///
 /// `DropletSpec`'s shape knobs are fractions OF THE BOX HEIGHT, which is what
 /// makes one spec survive a change to `module { height }` — the drop looks the
 /// same on a 24px bar and a 40px one. The expanded context menu breaks that
 /// assumption: it keeps the module's width and grows ten times taller, so the
 /// same fractions resolve to a bottom radius that hits the half-width clamp
 /// (a literal semicircle under a 10-row window picker) and a top taper eating
 /// 145px of a 345px box, while the rows are laid out as a plain rectangle
 /// inside it and overhang the silhouette at both ends.
 ///
 /// Scaling every height-fraction knob by `reference_h / box_h` makes them
 /// resolve to the SAME pixel values they would at `reference_h`, so the drop
 /// keeps exactly the silhouette it has collapsed and the body extends straight
 /// down. At the start of the expansion animation the factor is 1 and this is
 /// the identity, so there is nothing to pop.
 ///
 /// Only the knobs documented as fractions of height are touched. `belly_w` is
 /// a fraction of the remaining half-width, and the rest (`clarity`, `dome`,
 /// `gleam`, `shine`, `rim`, `curve`, `core`, `refr`, `ghost`, `shadow`) are
 /// strengths or exponents with no length in them.
 fn spec_at_reference_height(
     spec: cce_ui::scene::paint::DropletSpec,
     reference_h: f32,
     box_h: f32,
 ) -> cce_ui::scene::paint::DropletSpec {
     if box_h <= reference_h || reference_h <= 0.0 {
         return spec;
     }
     let k = reference_h / box_h;
     let mut out = spec;
     out.sag *= k;
     out.belly *= k;
     out.blend *= k;
     out.sheet_r *= k;
     out.attach *= k;
     out.bow *= k;
     out.band *= k;
     // The dome and its gleam FADE OUT as the box grows past the bar strip:
     // dome shading follows the rounded-rect SDF gradient, and on a box with
     // long straight sides that field creases along the corner diagonals —
     // full strength draws a blocky lit picture-frame (band pinned) or
     // envelope folds across the body (band grown); both were tried and read
     // as broken lighting rather than water. A tall panel is not a bead: the
     // expanded menu settles into a flat glass sheet that keeps the drop's
     // OTHER water terms — the thin-edge clarity falloff, the fresnel rim
     // crest along the lower arc, the core tint, the contact shadow — which
     // are all silhouette-hugging and crease-free. The ramp is continuous in
     // k — full lighting collapsed, gone once the box passes twice the bar
     // height — so the fade rides the expansion animation with nothing to
     // pop, and a real menu (k ≈ 0.1–0.2) lands at exactly zero.
     let lit = ((k - 0.5) * 2.0).clamp(0.0, 1.0);
     out.dome *= lit;
     out.gleam *= lit;
     out
 }
 
 /// The in-surface right-click menu: instead of spawning a popup process, the
 /// module's own surface EXPANDS below the bar strip to contain the menu. The
 /// compositor treats a status segment thicker than the bar as expanded — it
 /// keeps the segment's frozen slot, stops enforcing its size, and raises it
 /// above the windows the menu overlaps. Pages support DBusMenu submenus:
 /// tray icon menus navigate in place (`Submenu`/`Back` rows).
 struct ModuleContextMenu {
     pages: Vec<MenuPage>,
     page: usize,
     /// (destination, menu_path) — the DBusMenu owner `Item` rows dispatch
     /// to; None for the bar's own module menu.
     tray_target: Option<(String, String)>,
     min_w: f32,
     hovered: Option<usize>,
     /// Menu box in surface-local logical coords, set by `rebuild_layout`.
     rect: (f32, f32, f32, f32),
     /// Per-row (y offset from the menu top, height), parallel to the current
     /// page's rows; rebuilt with the layout (rows have mixed heights).
     row_bounds: Vec<(f32, f32)>,
 }
 
 impl ModuleContextMenu {
     const PAD: f32 = 6.0;
     const HEADER_H: f32 = 26.0;
     const ITEM_H: f32 = 28.0;
     const SEP_H: f32 = 9.0;
 
     fn rows(&self) -> &[MenuRow] {
         self.pages.get(self.page).map(|p| p.rows.as_slice()).unwrap_or(&[])
     }
 
     fn title(&self) -> &str {
         self.pages.get(self.page).map(|p| p.title.as_str()).unwrap_or("")
     }
 
     fn height(&self) -> f32 {
         let rows: f32 = self
             .rows()
             .iter()
             .map(|r| if r.separator { Self::SEP_H } else { Self::ITEM_H })
             .sum();
         2.0 * Self::PAD + Self::HEADER_H + rows
     }
 
     fn contains(&self, x: f32, y: f32) -> bool {
         let (mx, my, mw, mh) = self.rect;
         x >= mx && x <= mx + mw && y >= my && y <= my + mh
     }
 
     /// The interactive row under the pointer (separators, disabled and inert
     /// rows never match).
     fn item_at(&self, x: f32, y: f32) -> Option<usize> {
         if !self.contains(x, y) {
             return None;
         }
         let rel = y - self.rect.1;
         self.row_bounds
             .iter()
             .position(|&(off, h)| rel >= off && rel < off + h)
             .filter(|&i| {
                 self.rows().get(i).is_some_and(|r| {
                     !r.separator && r.enabled && !matches!(r.action, MenuRowAction::Inert)
                 })
             })
     }
 }
 
 pub(crate) fn make_text_buffer(fs: &mut FontSystem, text: &str, size: f32, font_family: &str) -> Buffer {
     make_text_buffer_weighted(fs, text, size, font_family, None)
 }
 
 /// `make_text_buffer` at an OpenType weight (`Some(700)` = bold) — the
 /// measurement the icon readouts' numbers need, since the engine shapes a
 /// weighted run with that face and its advances are the face's, not the
 /// regular's.
 pub(crate) fn make_text_buffer_weighted(fs: &mut FontSystem, text: &str, size: f32, font_family: &str, weight: Option<u16>) -> Buffer {
     let scale = cce_ui::scale::scale_factor();
     let mut font_size = size;
 
     let (parsed_family, parsed_size) = cce_ui::layout::parse_font_string(font_family);
     if let Some(ps) = parsed_size {
         font_size = ps;
     }
     let family_name = Some(parsed_family);
 
     let physical_size = font_size * scale;
     let metrics = Metrics::new(physical_size, physical_size * 1.4);
     let mut buf = Buffer::new(fs, metrics);
     let mut attrs = Attrs::new();
     if let Some(w) = weight {
         attrs = attrs.weight(cce_ui::cosmic_text::Weight(w));
     }
     // Same shaping rule as cce-ui's buffer path (ASCII in a mono face →
     // Basic, no ligatures), so this measurement agrees with what the engine
     // draws — an fi ligature applied on one side only would skew widths by a
     // full advance cell.
     let mut shaping = cce_ui::cosmic_text::Shaping::Advanced;
     if let Some(ref font_name) = family_name {
         let family = match font_name.as_str() {
             "monospace" => cce_ui::cosmic_text::Family::Name(cce_ui::layout::get_system_monospace_font()),
             "sans-serif" => cce_ui::cosmic_text::Family::SansSerif,
             "serif" => cce_ui::cosmic_text::Family::Serif,
             name => cce_ui::cosmic_text::Family::Name(name),
         };
         attrs = attrs.family(family);
         shaping = cce_ui::engine::shaping_for(fs, text, &family);
     }
     buf.set_text(fs, text, attrs, shaping);
     buf.shape_until_scroll(fs, true);
     buf
 }
 
 
 
 pub struct RectWidget {
     pub x: f32, pub y: f32, pub w: f32, pub h: f32,
     pub color: [f32; 4],
 }
 
 pub struct RoundedBox {
     pub x: f32, pub y: f32, pub w: f32, pub h: f32,
     pub radius: f32,
     pub color: [f32; 4],
     pub corners: (bool, bool, bool, bool),
     /// Some((color, thickness)): draw as an outlined shape — `color` fills
     /// (pass transparent for an empty ring) and the stroke uses this color
     /// and thickness. Skips the box bevel treatment.
     pub border: Option<([f32; 4], f32)>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Side {
     Left,
     Right,
 }
 
 #[derive(Debug, Clone)]
 pub struct ModuleBounds {
     pub name: String,
     pub side: Side,
     pub x: f32,
     pub w: f32,
 }
 
 
 struct StatusApp {
     // Status State
     layout: String,
     title: String,
     stats: Option<SystemStats>,
     tray_items: HashMap<String, TrayItem>,
     cursor_pos: (f64, f64),
     hovered_tray_item: Option<String>,
     tray_item_bounds: Vec<TrayIconBounds>,
 
     font_system: FontSystem,
     status_bar: cce_ui::widget::Adapted<cce_ui::widget::StatusBar>,
 
     rects: Vec<RectWidget>,
     overlay_rects: Vec<RectWidget>,
     rounded_boxes: Vec<RoundedBox>,
     /// Module boxes drawn as water droplets instead of `rounded_boxes` entries
     /// when `module { droplet }` is configured — (x, y, w, h, color, spec),
     /// painted first so module content sits on the drop.
     ///
     /// The spec rides each box rather than being read from `self.droplet` at
     /// paint time because the expanded menu box needs a DIFFERENT one — see
     /// `spec_at_reference_height`.
     droplet_boxes: Vec<(f32, f32, f32, f32, [f32; 4], cce_ui::scene::paint::DropletSpec)>,
     droplet: Option<cce_ui::scene::paint::DropletSpec>,
     text_prims: Vec<TextPrim>,
     /// The glyphs the stat modules paint their readouts on — see `IconPrim`.
     icon_prims: Vec<IconPrim>,
 
     scale_factor: f64,
     width: u32,
     height: u32,
     needs_rebuild: bool,
     box_bevel: Option<StatusBoxBevel>,
     box_bevel_depth: f32,
     context_menu: Option<ModuleContextMenu>,
     /// Expansion progress of the in-surface menu, 0 (strip) → 1 (fully
     /// open). Advanced/reversed in `tick`; `rebuild_layout` eases it into
     /// the box size, and `desired_size` grows the surface with it.
     menu_anim: f32,
     /// True while the menu is animating shut; `context_menu` is dropped
     /// only when the contraction lands back at the strip.
     menu_closing: bool,
     /// The drawn bubble's width, eased in `tick` toward `bubble_w_target`
     /// (the module's live `content_width`). The slot and the surface hold the
     /// stable `width()` — templates and title quantization keep the
     /// compositor from ever seeing a resize — while the bubble inside hugs
     /// the content, centered on the difference, so side padding stays the
     /// configured padding. Easing is what keeps a flapping window title from
     /// snapping the bubble edge on every change. 0 = not yet measured (the
     /// first rebuild snaps straight to the target). Single-module by
     /// construction: a `StatusApp` always hosts exactly one module, so one
     /// pair of fields covers "the" bubble.
     bubble_w_now: f32,
     bubble_w_target: f32,
     /// The collapsed bubble actually drawn this rebuild (x, w), slot coords —
     /// what the in-surface menu expansion grows out of and contracts back to.
     collapsed_box: Option<(f32, f32)>,
     /// The hovered menu row's highlight pill (x, y, w, h), set by the menu
     /// branch of `rebuild_layout` and drawn in `display_list` before the
     /// text.
     menu_hover_rect: Option<(f32, f32, f32, f32)>,
     input_regions: Vec<(i32, i32, i32, i32)>,
     module_bounds: Vec<ModuleBounds>,
     left_modules: Vec<Box<dyn StatusModule>>,
     right_modules: Vec<Box<dyn StatusModule>>,
     sender: calloop::channel::Sender<CustomEvent>,
     last_config_modified: Option<std::time::SystemTime>,
     selected_module_name: Option<String>,
     selected_module_side: Option<Side>,
     status_hide_mode: bool,
     adjust_position_mode: bool,
     /// Whether a renderer has been handed to this app yet. The first one is
     /// the one `new()`'s glyph uploads are queued for; every later one is a
     /// reconnect, and the ids retained in `icon_prims` name images that died
     /// with the renderer being replaced — see `renderer_init`.
     seen_renderer: bool,
 }
 
 /// The Wayland `app_id` a segment presents — the compositor places segments
 /// by it. The two spellings below are exactly the kind of thing that drifts
 /// when copied, so they live in one place.
 fn status_app_id(selected: Option<(&str, Side)>) -> String {
     let display = std::env::var("WAYLAND_DISPLAY").unwrap_or_else(|_| "wayland-0".to_string());
     let use_interface_prefix = std::path::Path::new(&format!("/tmp/cce-status-interface-{}.sock", display)).exists();
     let prefix = if use_interface_prefix { "cce-status-interface" } else { "cce-status" };
     match selected {
         Some((name, side)) => format!("{}-{:?}-{}", prefix, side, name).to_lowercase(),
         None => prefix.to_string(),
     }
 }
 
 impl StatusApp {
     fn get_app_id(&self) -> String {
         let selected = match (&self.selected_module_name, &self.selected_module_side) {
             (Some(name), Some(side)) => Some((name.as_str(), *side)),
             _ => None,
         };
         status_app_id(selected)
     }
 
     fn is_vertical(&self) -> bool {
         // An open in-surface menu makes the surface taller than wide; that
         // must not read as a vertical bar (menus only open on horizontal
         // segments).
         if self.context_menu.is_some() {
             return false;
         }
         let bar_thickness = read_status_height_from_config() as u32;
         if self.width == bar_thickness && self.height != bar_thickness {
             true
         } else if self.height == bar_thickness && self.width != bar_thickness {
             false
         } else if self.width < self.height {
             true
         } else if self.width > self.height {
             false
         } else {
             cce_ui::backend::text::vertical_text().is_some()
         }
     }
 
     #[allow(unused_assignments)]
     fn rebuild_layout(&mut self) {
         log::info!("[cce-status-interface] rebuild_layout module={:?} size={}x{}", self.selected_module_name, self.width, self.height);
         let is_vertical = self.is_vertical();
         let bar_thickness = read_status_height_from_config() as u32;
         cce_ui::backend::text::set_vertical_text(is_vertical.then_some(bar_thickness));
 
         // Family WITHOUT the embedded size: the toolkit's text pipeline lets
         // a size inside the font string ("Chivo Mono 14") override the
         // explicit font-size parameter, which would dead-end
         // `module { font_size }`. Size is resolved separately below.
         let (font_family, _) =
             cce_ui::layout::parse_font_string(&read_status_font_from_config());
         let font_size = read_status_font_size_from_config();
         let padding = read_status_padding_from_config();
         let spacing = read_status_module_spacing_from_config();
         let normal_color = read_normal_color_from_config().unwrap_or(color::TEXT_FG);
         let sw_logical = if is_vertical { self.height as f32 } else { self.width as f32 };
         let bar_h = if is_vertical { self.width as f32 } else { read_status_height_from_config() };
 
         self.rects.clear();
         self.overlay_rects.clear();
         self.rounded_boxes.clear();
         self.text_prims.clear();
         self.icon_prims.clear();
         self.input_regions.clear();
         self.module_bounds.clear();
         self.tray_item_bounds.clear();
         self.collapsed_box = None;
         self.menu_hover_rect = None;
 
         let left_modules = std::mem::take(&mut self.left_modules);
         let right_modules = std::mem::take(&mut self.right_modules);
 
         let box_bg_color = read_status_box_background_color_from_config();
         let status_box_radius = read_status_box_corner_radius_from_config();
         self.box_bevel = read_status_box_bevel_from_config();
         self.box_bevel_depth = read_status_box_bevel_depth_from_config();
         self.droplet = read_droplet_from_config();
         self.droplet_boxes.clear();
 
         self.status_bar.set_rect(0.0, 0.0, self.width as f32, self.height as f32);
         // The surface itself is transparent: every StatusApp is a single
         // `--module` segment (the no-arg form is the launcher daemon and
         // never creates a surface), so the only painted background is each
         // module's own rounded box.
         self.status_bar.set_bg_color([0.0, 0.0, 0.0, 0.0]);
 
 
         let is_single = self.selected_module_name.is_some();
         let margin_padding = if is_single { 6.0 } else { 12.0 };
 
         let mut left_x = margin_padding;
         let mut is_first_left = true;
         for module in &left_modules {
             let w = module.width(
                 &self.stats,
                 &self.title,
                 &mut self.font_system,
                 &font_family,
                 font_size,
                 &self.tray_items,
                 padding,
             );
             if w > 0.0 {
                 if !is_first_left {
                     left_x += spacing;
                 }
                 is_first_left = false;
 
                 // The bubble hugs the LIVE content, centered in the stable
                 // slot: `width()` keeps the surface from resizing (the
                 // configure-echo jitter), while the drawn box shrinks so the
                 // padding on each side of the text is the configured padding
                 // rather than padding-plus-template-surplus. The drawn width
                 // is `bubble_w_now`, eased toward the live measure in `tick`.
                 let cw = module
                     .content_width(&self.stats, &self.title, &mut self.font_system, &font_family, font_size, &self.tray_items, padding)
                     .min(w);
                 self.bubble_w_target = cw;
                 if self.bubble_w_now <= 0.0 {
                     self.bubble_w_now = cw;
                 }
                 let bw = self.bubble_w_now.min(w);
                 let bx = left_x + (w - bw) / 2.0;
                 self.collapsed_box = Some((bx, bw));
 
                 // With the in-surface menu open the module box is replaced by
                 // the unified expanded box drawn in the menu branch below —
                 // the module box GROWS into the menu, it doesn't sit atop it.
                 if !module.has_custom_background(&self.title) && self.context_menu.is_none() {
                     if let Some(color) = box_bg_color {
                         if let Some(spec) = self.droplet {
                             // Inset from the surface bottom: 1px for the
                             // belly silhouette's AA feather, plus the
                             // contact shadow's reserved gap.
                             let inset = 1.0 + spec.shadow_gap(bar_h);
                             self.droplet_boxes.push((bx, 0.0, bw, bar_h - inset, color, spec));
                         } else {
                             self.rounded_boxes.push(RoundedBox {
                                 x: bx,
                                 y: 0.0,
                                 w: bw,
                                 h: bar_h,
                                 radius: status_box_radius,
                                 color,
                                 corners: if self.selected_module_name.is_some() { (true, true, true, true) } else { (false, false, true, true) },
                                 border: None,
                             });
                         }
                     }
                 }
 
                 module.render(
                     bx,
                     bw,
                     &self.stats,
                     &self.title,
                     &mut self.font_system,
                     &font_family,
                     font_size,
                     normal_color,
                     bar_h,
                     self.scale_factor,
                     &mut self.text_prims,
                     &mut self.icon_prims,
                     &mut self.rects,
                     &mut self.overlay_rects,
                     &self.tray_items,
                     &mut self.tray_item_bounds,
                     box_bg_color,
                     status_box_radius,
                     &mut self.rounded_boxes,
                     padding,
                 );
 
                 self.module_bounds.push(ModuleBounds {
                     name: module.name().to_string(),
                     side: Side::Left,
                     x: left_x,
                     w,
                 });
                 self.input_regions.push((left_x.round() as i32, 0, w.round() as i32, bar_h.round() as i32));
                 left_x += w;
             }
         }
 
         let mut right_x = sw_logical - 12.0;
         let mut is_first_right = true;
         
         for module in right_modules.iter().rev() {
             let w = module.width(
                 &self.stats,
                 &self.title,
                 &mut self.font_system,
                 &font_family,
                 font_size,
                 &self.tray_items,
                 padding,
             );
             if w > 0.0 {
                 if !is_first_right {
                     right_x -= spacing;
                 }
                 is_first_right = false;
 
                 right_x -= w;
                 self.module_bounds.push(ModuleBounds {
                     name: module.name().to_string(),
                     side: Side::Right,
                     x: right_x,
                     w,
                 });
                 self.input_regions.push((right_x.round() as i32, 0, w.round() as i32, bar_h.round() as i32));
 
                 // See the left loop: the bubble hugs the eased live content
                 // width, centered in the stable slot.
                 let cw = module
                     .content_width(&self.stats, &self.title, &mut self.font_system, &font_family, font_size, &self.tray_items, padding)
                     .min(w);
                 self.bubble_w_target = cw;
                 if self.bubble_w_now <= 0.0 {
                     self.bubble_w_now = cw;
                 }
                 let bw = self.bubble_w_now.min(w);
                 let bx = right_x + (w - bw) / 2.0;
                 self.collapsed_box = Some((bx, bw));
 
                 // See the left loop: an open in-surface menu swaps the module
                 // box for the unified expanded box.
                 if !module.has_custom_background(&self.title) && self.context_menu.is_none() {
                     if let Some(color) = box_bg_color {
                         if let Some(spec) = self.droplet {
                             // Same bottom inset as the left loop.
                             let inset = 1.0 + spec.shadow_gap(bar_h);
                             self.droplet_boxes.push((bx, 0.0, bw, bar_h - inset, color, spec));
                         } else {
                             self.rounded_boxes.push(RoundedBox {
                                 x: bx,
                                 y: 0.0,
                                 w: bw,
                                 h: bar_h,
                                 radius: status_box_radius,
                                 color,
                                 corners: if self.selected_module_name.is_some() { (true, true, true, true) } else { (false, false, true, true) },
                                 border: None,
                             });
                         }
                     }
                 }
 
                 module.render(
                     bx,
                     bw,
                     &self.stats,
                     &self.title,
                     &mut self.font_system,
                     &font_family,
                     font_size,
                     normal_color,
                     bar_h,
                     self.scale_factor,
                     &mut self.text_prims,
                     &mut self.icon_prims,
                     &mut self.rects,
                     &mut self.overlay_rects,
                     &self.tray_items,
                     &mut self.tray_item_bounds,
                     box_bg_color,
                     status_box_radius,
                     &mut self.rounded_boxes,
                     padding,
                 );
 
                 if module.name() == "tray" {
                     right_x -= padding;
                 }
             }
         }
 
         // 5c. Tooltip Rendering (if hovered) — suppressed while the
         // in-surface menu is open (the tooltip would overlap the menu header).
         if let Some(ref hovered_id) = self.hovered_tray_item.clone().filter(|_| self.context_menu.is_none()) {
             if let Some(bound) = self.tray_item_bounds.iter().find(|b| &b.id == hovered_id) {
                 let clean_tooltip = |title: Option<&str>, dbus_id: Option<&str>, fallback_id: &str| -> String {
                     if let Some(t) = title {
                         let trimmed = t.trim();
                         if !trimmed.is_empty() {
                             return trimmed.to_string();
                         }
                     }
                     if let Some(id) = dbus_id {
                         let trimmed = id.trim();
                         if !trimmed.is_empty() {
                             let cleaned = trimmed
                                 .split('_')
                                 .next()
                                 .unwrap_or(trimmed)
                                 .split('-')
                                 .next()
                                 .unwrap_or(trimmed);
                             if !cleaned.is_empty() && cleaned.chars().any(|c| c.is_alphabetic()) {
                                 let mut chars = cleaned.chars();
                                 if let Some(first) = chars.next() {
                                     return first.to_uppercase().collect::<String>() + chars.as_str();
                                 }
                                 return cleaned.to_string();
                             }
                             return trimmed.to_string();
                         }
                     }
                     let last_segment = fallback_id.split('/').next_back().unwrap_or(fallback_id);
                     let cleaned = last_segment
                         .split('_')
                         .next()
                         .unwrap_or(last_segment)
                         .split('-')
                         .next()
                         .unwrap_or(last_segment);
                     if !cleaned.is_empty() && cleaned.chars().any(|c| c.is_alphabetic()) {
                         let mut chars = cleaned.chars();
                         if let Some(first) = chars.next() {
                             return first.to_uppercase().collect::<String>() + chars.as_str();
                         }
                         return cleaned.to_string();
                     }
                     last_segment.to_string()
                 };
 
                 let tooltip_text = clean_tooltip(
                     bound.title.as_deref(),
                     bound.dbus_id.as_deref(),
                     bound.id.as_str(),
                 );
                 let tooltip_font_size = font_size - 1.0;
                 let buf = make_text_buffer(&mut self.font_system, &tooltip_text, tooltip_font_size, &font_family);
                 let scale = cce_ui::scale::scale_factor();
                 let text_w = buf.layout_runs().next().map(|r| r.line_w).unwrap_or(0.0) / scale;
                 let padding = 6.0;
 
                 let tooltip_w = text_w + padding * 2.0;
                 let tooltip_w_h = tooltip_font_size * 1.4 + padding * 2.0;
                 let tx = bound.x + (bound.w - tooltip_w) / 2.0;
                 let ty = bar_h + 4.0;
 
                 // Tooltip background
                 self.rects.push(RectWidget {
                     x: tx,
                     y: ty,
                     w: tooltip_w,
                     h: tooltip_w_h,
                     color: [0.08, 0.08, 0.12, 0.95],
                 });
 
                 // Tooltip text
                 let _ = buf; // shaped only to measure `text_w` above
                 self.text_prims.push((
                     tooltip_text.clone(),
                     tooltip_font_size,
                     tx + padding,
                     ty + padding,
                     [
                         (color::TEXT_FG[0] * 255.0) as u8,
                         (color::TEXT_FG[1] * 255.0) as u8,
                         (color::TEXT_FG[2] * 255.0) as u8,
                     ],
                     Some(font_family.clone()),
                     None,
                     None,
                     None,
                 ));
             }
         }
 
         if self.selected_module_name.is_some() {
             if is_vertical {
                 let old_h = self.height;
                 self.height = (left_x + margin_padding).round() as u32;
                 log::debug!("[module-{}] rebuild_layout vertical: height calculated as {} (was {})", self.selected_module_name.as_deref().unwrap_or("none"), self.height, old_h);
                 self.input_regions.clear();
                 self.input_regions.push((0, 0, self.width as i32, self.height as i32));
             } else {
                 let old_w = self.width;
                 self.width = (left_x + margin_padding).round() as u32;
                 log::debug!("[module-{}] rebuild_layout horizontal: width calculated as {} (was {})", self.selected_module_name.as_deref().unwrap_or("none"), self.width, old_w);
                 self.input_regions.clear();
                 self.input_regions.push((0, 0, self.width as i32, bar_h.round() as i32));
 
                 // No open menu: the surface is exactly the bar strip. This
                 // reset is what COLLAPSES an expanded surface after the menu
                 // closes — the compositor deliberately stops enforcing size
                 // while we are thicker than the bar, so nobody else will.
                 if self.context_menu.is_none() {
                     self.height = bar_h.round() as u32;
                 }
 
                 // In-surface context menu: grow the surface below the bar
                 // strip and draw the current page into the retained buffers.
                 // The panel reuses the module box pipeline (so box_bevel
                 // applies) with rows, separators and a hover highlight on top.
                 if let Some(menu) = &mut self.context_menu {
                     // The unified box keeps the module box's own margin so the
                     // strip band reads as the module box, grown.
                     let plate_x = margin_padding;
                     let module_box_w = self.width as f32 - 2.0 * plate_x;
                     // Wide enough for the longest row label — fixed minimums
                     // truncated window titles in the picker.
                     let tx_probe = ModuleContextMenu::PAD + 8.0;
                     // The glyph columns (see `menu_row_glyphs`): one at the
                     // left, reserved on every row of a page where any row
                     // has a mark or a back chevron so the labels share one
                     // edge, and a chevron at the right end of a page row.
                     let mark_side = (font_size * 0.95).round();
                     let chevron_side = (font_size * 0.8).round();
                     let glyph_gap = 6.0;
                     let lead_w = if menu.rows().iter().any(|r| !r.separator && menu_row_glyphs(r).0.is_some()) {
                         mark_side + glyph_gap
                     } else {
                         0.0
                     };
                     let mut label_w: f32 = 0.0;
                     for page_row in menu.rows().to_vec() {
                         if !page_row.separator {
                             let (_, text, trail) = menu_row_glyphs(&page_row);
                             let l = cce_ui::widget::StyledLabel::new_with_family(&mut self.font_system, text, font_size, [0.0, 0.0, 0.0, 1.0], &font_family);
                             let trail_w = if trail.is_some() { glyph_gap + chevron_side } else { 0.0 };
                             label_w = label_w.max(lead_w + l.w + trail_w);
                         }
                     }
                     let menu_w = module_box_w.max(menu.min_w).max(label_w + 2.0 * tx_probe);
                     let menu_h = menu.height();
                     // Expansion animation: ease `menu_anim` (stepped in tick)
                     // into the box, growing width and revealing height from
                     // the collapsed module box. Rows keep their final
                     // positions and slide into view as the surface bottom
                     // edge (which clips them) travels down.
                     let t = {
                         let a = self.menu_anim.clamp(0.0, 1.0);
                         1.0 - (1.0 - a) * (1.0 - a) * (1.0 - a)
                     };
                     // The expansion grows out of the bubble actually drawn on
                     // the strip — which may sit inset in its slot, hugging
                     // the live content — not out of the slot itself, so the
                     // "module box grows into the menu" continuity holds with
                     // content-hugging bubbles. Contraction reverses back to
                     // the same collapsed box.
                     let (start_x, start_w) = self.collapsed_box.unwrap_or((plate_x, module_box_w));
                     let anim_w = start_w + (menu_w - start_w) * t;
                     let anim_x = start_x + (plate_x - start_x) * t;
                     let reveal_h = menu_h * t;
                     menu.rect = (anim_x, bar_h, anim_w, reveal_h);
                     self.width = self.width.max((anim_x + anim_w + plate_x).round() as u32);
                     self.height = (bar_h + reveal_h).round() as u32;
 
                     // ONE continuous box in the module's own fill, spanning
                     // the strip band and the menu — the module box literally
                     // grows into the menu. Inserted at the front so the
                     // module's strip content (tray icons, labels)
                     // renders on top of its band. In droplet style the drop
                     // grows DOWNWARD without growing its curvature: the knobs
                     // are re-resolved against the collapsed height, so the
                     // taper and the bottom corners stay the size they are on
                     // the bar and the sides run straight between them. Letting
                     // them scale with the box is what stopped the backdrop
                     // conforming to the rows it is behind.
                     let menu_color = box_bg_color.unwrap_or([0.055, 0.055, 0.075, 0.97]);
                     if let Some(spec) = self.droplet {
                         let inset = 1.0 + spec.shadow_gap(bar_h);
                         let collapsed_h = bar_h - inset;
                         let box_h = bar_h + reveal_h - inset;
                         let menu_spec = spec_at_reference_height(spec, collapsed_h, box_h);
                         self.droplet_boxes.push((anim_x, 0.0, anim_w, box_h, menu_color, menu_spec));
                     } else {
                         self.rounded_boxes.insert(0, RoundedBox {
                             x: anim_x,
                             y: 0.0,
                             w: anim_w,
                             h: bar_h + reveal_h,
                             radius: status_box_radius.max(4.0),
                             color: menu_color,
                             corners: (true, true, true, true),
                             border: None,
                         });
                     }
 
                     let text_u8 = [
                         (normal_color[0] * 255.0) as u8,
                         (normal_color[1] * 255.0) as u8,
                         (normal_color[2] * 255.0) as u8,
                     ];
                     let dim_u8 = [
                         (normal_color[0] * 150.0) as u8,
                         (normal_color[1] * 150.0) as u8,
                         (normal_color[2] * 150.0) as u8,
                     ];
                     let tx = plate_x + ModuleContextMenu::PAD + 8.0;
                     self.text_prims.push((
                         menu.title().to_string(),
                         font_size,
                         tx,
                         bar_h + ModuleContextMenu::PAD
                             + (ModuleContextMenu::HEADER_H - font_size) / 2.0,
                         dim_u8,
                         Some(font_family.clone()),
                         None,
                         None,
                         None,
                     ));
 
                     let rows = menu.rows().to_vec();
                     let hovered = menu.hovered;
                     let mut bounds = Vec::with_capacity(rows.len());
                     let mut off = ModuleContextMenu::PAD + ModuleContextMenu::HEADER_H;
                     for (i, row) in rows.iter().enumerate() {
                         let h = if row.separator {
                             ModuleContextMenu::SEP_H
                         } else {
                             ModuleContextMenu::ITEM_H
                         };
                         let iy = bar_h + off;
                         if row.separator {
                             self.rects.push(RectWidget {
                                 x: tx,
                                 y: iy + h / 2.0,
                                 w: anim_w - 2.0 * (ModuleContextMenu::PAD + 8.0),
                                 h: 1.0,
                                 color: [0.35, 0.35, 0.42, 0.8],
                             });
                         } else {
                             if hovered == Some(i) && row.enabled {
                                 // A rounded pill inset from the panel edge,
                                 // drawn before the text in display_list — a
                                 // square-cornered full-width rect butting
                                 // into the rounded silhouette was the last
                                 // blocky element of the expanded menu.
                                 self.menu_hover_rect =
                                     Some((anim_x + 6.0, iy + 1.0, anim_w - 12.0, h - 2.0));
                             }
                             let tint = if row.enabled { text_u8 } else { dim_u8 };
                             let (lead, text, trail) = menu_row_glyphs(row);
                             if let Some(name) = lead {
                                 let side = if lead == Some("chevron-left") { chevron_side } else { mark_side };
                                 if let Some((image, gw, gh)) = crate::icons::glyph(name, side, tint) {
                                     self.icon_prims.push(IconPrim {
                                         image,
                                         x: tx + (mark_side - gw) / 2.0,
                                         y: iy + (h - gh) / 2.0,
                                         w: gw,
                                         h: gh,
                                         alpha: 1.0,
                                     });
                                 }
                             }
                             if let Some(name) = trail {
                                 if let Some((image, gw, gh)) = crate::icons::glyph(name, chevron_side, tint) {
                                     self.icon_prims.push(IconPrim {
                                         image,
                                         x: anim_x + anim_w - (ModuleContextMenu::PAD + 8.0) - gw,
                                         y: iy + (h - gh) / 2.0,
                                         w: gw,
                                         h: gh,
                                         alpha: 1.0,
                                     });
                                 }
                             }
                             self.text_prims.push((
                                 text.to_string(),
                                 font_size,
                                 tx + lead_w,
                                 iy + (h - font_size) / 2.0,
                                 tint,
                                 Some(font_family.clone()),
                                 None,
                                 None,
                                 None,
                             ));
                         }
                         bounds.push((off, h));
                         off += h;
                     }
                     menu.row_bounds = bounds;
 
                     self.input_regions.clear();
                     self.input_regions.push((0, 0, self.width as i32, self.height as i32));
                 }
             }
         }
 
         if is_vertical {
             // Rotate rounded_boxes
             for rb in &mut self.rounded_boxes {
                 let old_x = rb.x;
                 let old_y = rb.y;
                 let old_w = rb.w;
                 let old_h = rb.h;
                 rb.x = old_y;
                 rb.y = old_x;
                 rb.w = old_h;
                 rb.h = old_w;
             }
             // Rotate rects
             for r in &mut self.rects {
                 let old_x = r.x;
                 let old_y = r.y;
                 let old_w = r.w;
                 let old_h = r.h;
                 r.x = old_y;
                 r.y = old_x;
                 r.w = old_h;
                 r.h = old_w;
             }
             // Rotate text prims (swap x/y — tuple fields .2 and .3)
             for tp in &mut self.text_prims {
                 let old_x = tp.2;
                 let old_y = tp.3;
                 tp.2 = old_y;
                 tp.3 = old_x;
             }
             // Rotate icon prims (square glyphs, so only the corner moves)
             for ip in &mut self.icon_prims {
                 let (old_x, old_y, old_w, old_h) = (ip.x, ip.y, ip.w, ip.h);
                 ip.x = old_y;
                 ip.y = old_x;
                 ip.w = old_h;
                 ip.h = old_w;
             }
             // Rotate tray_item_bounds
             for tib in &mut self.tray_item_bounds {
                 let old_x = tib.x;
                 let old_y = tib.y;
                 let old_w = tib.w;
                 let old_h = tib.h;
                 tib.x = old_y;
                 tib.y = old_x;
                 tib.w = old_h;
                 tib.h = old_w;
             }
         }
 
         self.left_modules = left_modules;
         self.right_modules = right_modules;
         self.needs_rebuild = false;
     }
 
     fn trigger_switcher(&mut self, is_switcher_mode: bool) {
         // Keyboard alt-tab switching is implemented natively by the compositor
         // (bound to super+tab via the window_manager.window_switcher config key).
         // Delegate to it so there is a single window-switcher implementation.
         if is_switcher_mode {
             std::thread::spawn(|| {
                 let _ = std::process::Command::new(get_ccectl_cmd())
                     .arg("window-switcher")
                     .spawn();
             });
             return;
         }
 
         // Otherwise this is a click on the status-bar "window" module: open
         // the click-to-pick window list as an IN-SURFACE menu (the window
         // module's own surface expands below the strip).
         let thread_sender = self.sender.clone();
         std::thread::spawn(move || {
             let output = std::process::Command::new(get_ccectl_cmd())
                 .args(["windows", "--json"])
                 .output();
             let windows = if let Ok(out) = output {
                 parse_ccectl_windows(&String::from_utf8_lossy(&out.stdout))
             } else {
                 Vec::new()
             };
             if windows.is_empty() {
                 return;
             }
             let rows = windows
                 .into_iter()
                 // The bar's own segments are noise in a window picker.
                 .filter(|(_, app_id, _, _)| !app_id.starts_with("cce-status"))
                 .map(|(id, app_id, title, _)| {
                     let display = if title.is_empty() {
                         app_id.clone()
                     } else {
                         format!("{} ({})", title, app_id)
                     };
                     MenuRow {
                         label: display,
                         enabled: true,
                         separator: false,
                         action: MenuRowAction::Ccectl(vec!["focus-window".to_string(), id]),
                     }
                 })
                 .collect();
             let _ = thread_sender.send(CustomEvent::MenuReady {
                 title: "Windows".to_string(),
                 pages: vec![MenuPage { title: "Windows".to_string(), rows }],
                 min_w: 260.0,
             });
         });
     }
 }
 
 
 fn get_module_side(name: &str) -> Side {
     module_side_from_json(&get_cached_config(), name)
 }
 
 fn module_side_from_json(val: &serde_json::Value, name: &str) -> Side {
     if name == "light_source" {
         // The light module ignores any status_bar side entry: it sits on
         // whichever side the configured light angle points at.
         let light_pos = crate::config::light_source_position_from(val);
 
         let two_pi = 2.0 * std::f32::consts::PI;
         let mut angle = light_pos % two_pi;
         if angle < 0.0 {
             angle += two_pi;
         }
 
         let pi = std::f32::consts::PI;
         // Side mapping: Left side is roughly [5pi/8, 11pi/8)
         if angle >= 5.0 * pi / 8.0 && angle < 11.0 * pi / 8.0 {
             return Side::Left;
         } else {
             return Side::Right;
         }
     }
 
     // Canonical: `layout { status_bar <name>="top-left" }` — the same key the
     // compositor persists a super+drag snap into.
     let pointer = format!("/layout/status_bar/{}", name);
     if let Some(side_val) = val.pointer(&pointer) {
         if let Some(side_str) = side_val.as_str() {
             match side_str.to_lowercase().as_str() {
                 "left" | "top-left" | "bottom-left" | "top-center" | "bottom-center" => return Side::Left,
                 "right" | "top-right" | "bottom-right" => return Side::Right,
                 _ => {}
             }
         }
     }
     match name {
         "window" => Side::Left,
         _ => Side::Right,
     }
 }
 
 fn parse_selected_module_from_args() -> Option<(String, Side)> {
     let args: Vec<String> = std::env::args().collect();
     for i in 0..args.len() {
         if args[i] == "--module" && i + 1 < args.len() {
             let name = args[i + 1].clone();
             let side = get_module_side(&name);
             return Some((name, side));
         }
     }
     None
 }
 
 /// Ask the compositor for the current adjust-position-mode state
 /// (`ccectl adjust-position-mode query` → `ok true|false`). `None` when the
 /// query fails or the reply is unrecognized. Note: a pre-query compositor
 /// treats the `query` argument as a toggle — the two repos ship together.
 pub(crate) fn query_adjust_position_mode() -> Option<bool> {
     let out = std::process::Command::new(get_ccectl_cmd())
         .args(["adjust-position-mode", "query"])
         .output()
         .ok()?;
     match String::from_utf8_lossy(&out.stdout).trim() {
         "ok true" => Some(true),
         "ok false" => Some(false),
         _ => None,
     }
 }
 
 /// Where this segment sits on screen: (x, y, height) in logical px, from
 /// `ccectl windows --json`. `None` when the compositor does not list it.
 pub(crate) fn segment_screen_rect(app_id: &str) -> Option<(i32, i32, i32)> {
     let out = std::process::Command::new(get_ccectl_cmd())
         .args(["windows", "--json"])
         .output()
         .ok()?;
     segment_rect_in(&String::from_utf8_lossy(&out.stdout), app_id)
 }
 
 /// `segment_screen_rect`'s parse, split out to test.
 pub(crate) fn segment_rect_in(windows_json: &str, app_id: &str) -> Option<(i32, i32, i32)> {
     windows_json.lines().find_map(|line| {
         let v: serde_json::Value = serde_json::from_str(line).ok()?;
         if v.get("app_id")?.as_str()? != app_id {
             return None;
         }
         let n = |k: &str| v.get(k).and_then(|x| x.as_i64()).map(|x| x as i32);
         Some((n("x")?, n("y")?, n("h")?))
     })
 }
 
 /// The SNI `Activate`/`ContextMenu` point for a click at segment-local
 /// (`cx`, `cy`): SCREEN coordinates, as the spec asks, with the y at the
 /// segment's bottom edge so a menu the app opens there hangs below the bar
 /// instead of over it. Without the segment's position (compositor not
 /// answering) the local point is all there is.
 pub(crate) fn tray_click_point(segment: Option<(i32, i32, i32)>, cx: i32, cy: i32) -> (i32, i32) {
     match segment {
         Some((x, y, h)) => (x + cx, y + h),
         None => (cx, cy),
     }
 }
 
 /// One window from `ccectl windows` output: (id, app_id, title, focused).
 pub(crate) type CcectlWindow = (String, String, String, bool);
 
 /// Parse one line of `ccectl windows` output. `window id=` and `app_id=` are
 /// required; `title="…"` (truncated at the first inner quote — the wire format
 /// does not escape) and `focused=` are optional.
 pub(crate) fn parse_ccectl_window_line(line: &str) -> Option<CcectlWindow> {
     let app_id = {
         let idx = line.find("app_id=")?;
         let rest = &line[idx + 7..];
         let end = rest.find(' ').unwrap_or(rest.len());
         rest[..end].to_string()
     };
 
     let title = if let Some(idx) = line.find("title=\"") {
         let rest = &line[idx + 7..];
         let end = rest.find('"').unwrap_or(rest.len());
         rest[..end].to_string()
     } else {
         "".to_string()
     };
 
     let focused = if let Some(idx) = line.find("focused=") {
         let rest = &line[idx + 8..];
         let end = rest.find(' ').unwrap_or(rest.len());
         rest[..end].trim() == "true"
     } else {
         false
     };
 
     let id = {
         let idx = line.find("window id=")?;
         let rest = &line[idx + 10..];
         let end = rest.find(' ').unwrap_or(rest.len());
         rest[..end].to_string()
     };
 
     Some((id, app_id, title, focused))
 }
 
 /// Parse one line of `ccectl windows --json` output.
 pub(crate) fn parse_ccectl_window_json_line(line: &str) -> Option<CcectlWindow> {
     let v: serde_json::Value = serde_json::from_str(line).ok()?;
     let id = v.get("id")?.as_u64()?.to_string();
     let app_id = v.get("app_id")?.as_str()?.to_string();
     let title = v.get("title").and_then(|t| t.as_str()).unwrap_or("").to_string();
     let focused = v.get("focused").and_then(|f| f.as_bool()).unwrap_or(false);
     Some((id, app_id, title, focused))
 }
 
 /// Parse one `ccectl windows` line in either format — JSON (`--json`) when the
 /// compositor supports it, otherwise the legacy text format (an older
 /// compositor ignores the `--json` flag and answers in text; titles containing
 /// `"` are then truncated at the quote).
 pub(crate) fn parse_ccectl_window_any_line(line: &str) -> Option<CcectlWindow> {
     if line.trim_start().starts_with('{') {
         parse_ccectl_window_json_line(line)
     } else {
         parse_ccectl_window_line(line)
     }
 }
 
 /// Parse `ccectl windows [--json]` output, dropping this app's own surfaces and
 /// cce-cloud popups (they should never appear in the window picker).
 pub(crate) fn parse_ccectl_windows(output: &str) -> Vec<CcectlWindow> {
     output
         .lines()
         .filter_map(parse_ccectl_window_any_line)
         .filter(|(_, app_id, _, _)| {
             app_id != "cce-status" && app_id != "cce-status-interface" && app_id != "cce-cloud"
         })
         .collect()
 }
 
 /// The frame's text as prim data: (text, size, x, y, color_u8, font, bounds, box-layout).
 /// The last field is the run's OpenType weight (`Some(700)` = bold), `None`
 /// for the face's regular; only the icon readouts' numbers set it.
 pub(crate) type TextPrim = (String, f32, f32, f32, [u8; 3], Option<String>, Option<[f32; 4]>, Option<cce_ui::scene::paint::TextLayout>, Option<u16>);
 
 /// Emit a measured `StyledLabel` as a text-prim tuple, returning its width (like the legacy
 /// `StyledLabel::draw`). The label was built for its width; `into_prim` carries the source
 /// text/size/family/box-layout so the engine reshapes it through the shared cache.
 pub(crate) fn draw_label(prims: &mut Vec<TextPrim>, label: cce_ui::widget::StyledLabel, x: f32, y: f32) -> f32 {
     let w = label.w;
     let p = label.into_prim(x, y);
     prims.push((p.text, p.size, p.x, p.y, p.color, p.font, None, p.layout, None));
     w
 }
 
 impl cce_ui::engine::Application for StatusApp {
     type Message = CustomEvent;
 
     /// The status bar is a systemd user service the compositor does not
     /// restore, so it waits for the next compositor instead of exiting with
     /// this one. Exiting took the tray module's StatusNotifierWatcher off the
     /// bus at every logout, and Dropbox, starting into the gap before the
     /// launcher's backoff restarted the module, found no tray.
     fn outlives_compositor(&self) -> bool {
         true
     }
 
     fn create(sender: cce_ui::engine::AppSender<Self::Message>) -> Self {
         // The app keeps calloop's sender; `AppSender` converts into it.
         let sender: calloop::channel::Sender<Self::Message> = sender.into();
         let selected_module = parse_selected_module_from_args();
 
         let mut left_modules: Vec<Box<dyn StatusModule>> = Vec::new();
         let right_modules: Vec<Box<dyn StatusModule>> = Vec::new();
 
         let mut has_window = false;
 
         let (ref name, _) = selected_module
             .as_ref()
             .expect("StatusApp requires --module <name>; the no-arg form runs the launcher daemon");
         let module: Box<dyn StatusModule> = match name.as_str() {
             "window" => {
                 has_window = true;
                 Box::new(WindowModule)
             }
             "tray" => Box::new(TrayModule),
             "cpu" => Box::new(CpuModule),
             "memory" => Box::new(MemoryModule),
             "brightness" => Box::new(BrightnessModule),
             "volume" => Box::new(VolumeModule),
             "battery" => Box::new(BatteryModule),
             "wifi" => Box::new(WifiModule),
             "stats" => Box::new(StatsModule),
             "clock" => Box::new(ClockModule),
             "light_source" => Box::new(LightSourceModule),
             _ => panic!("Unknown module: {}", name),
         };
         left_modules.push(module);
 
         if has_window {
             tokio::spawn(spawn_status_listener("layout".to_string(), sender.clone()));
             tokio::spawn(spawn_status_listener("title".to_string(), sender.clone()));
         }
         // Every module can host an in-surface menu, so every process listens
         // for the compositor's click-away dismiss pushes.
         tokio::spawn(spawn_status_listener("dismiss".to_string(), sender.clone()));
         let is_primary_for_switcher = selected_module.as_ref().is_none_or(|(name, _)| name == "window");
         if is_primary_for_switcher {
             tokio::spawn(spawn_switcher_listener(sender.clone()));
         }
 
         let has_tray = selected_module.as_ref().is_none_or(|(name, _)| name == "tray");
         if has_tray {
             tokio::spawn(spawn_status_tray(sender.clone()));
         }
         let has_stats = selected_module.as_ref().is_none_or(|(name, _)| {
             name == "stats" || name == "cpu" || name == "memory" || name == "brightness" || name == "volume" || name == "battery" || name == "wifi" || name == "clock"
         });
         // The backlight and the sink are what a keypress moves, so they get a
         // fast path instead of the one-second poll — only where a module
         // actually paints one of them.
         let module_name = selected_module.as_ref().map(|(n, _)| n.clone());
         let fast_levels = has_fast_levels(module_name.as_deref());
         if has_stats {
             tokio::spawn(spawn_system_stats(sender.clone(), module_name, fast_levels));
         }
         if fast_levels {
             let sender = sender.clone();
             tokio::spawn(spawn_level_watchers(move |change| {
                 let _ = sender.send(change.into());
             }));
         }
 
         let font_system = cce_ui::create_font_system();
 
         let mut app = Self {
             layout: String::new(),
             title: String::new(),
             stats: if has_stats { Some(get_initial_stats()) } else { None },
             tray_items: HashMap::new(),
             cursor_pos: (0.0, 0.0),
             hovered_tray_item: None,
             tray_item_bounds: Vec::new(),
             font_system,
             status_bar: cce_ui::widget::StatusBar::new(),
             rects: Vec::new(),
             overlay_rects: Vec::new(),
             rounded_boxes: Vec::new(),
             droplet_boxes: Vec::new(),
             droplet: None,
             text_prims: Vec::new(),
             icon_prims: Vec::new(),
             scale_factor: 1.0,
             width: if selected_module.is_some() { 120 } else { 1920 },
             height: read_status_height_from_config() as u32,
             needs_rebuild: true,
             box_bevel: None,
             box_bevel_depth: 3.0,
             context_menu: None,
             menu_anim: 0.0,
             menu_closing: false,
             menu_hover_rect: None,
             bubble_w_now: 0.0,
             bubble_w_target: 0.0,
             collapsed_box: None,
             input_regions: Vec::new(),
             module_bounds: Vec::new(),
             left_modules,
             right_modules,
             sender,
             last_config_modified: cce_ui::config::config_files_modified(),
             selected_module_name: selected_module.as_ref().map(|(n, _)| n.clone()),
             selected_module_side: selected_module.as_ref().map(|(_, s)| *s),
             status_hide_mode: false,
             adjust_position_mode: false,
             seen_renderer: false,
         };
 
         app.rebuild_layout();
         app
     }
 
 
 
     /// A bar segment is placed by the compositor: no client-side move,
     /// resize or resize cursors. (cce-ui used to infer this from the app id.)
     fn standard_csd(&self) -> bool {
         false
     }
 
     fn settings(&self) -> cce_ui::engine::WindowSettings {
         let app_id = self.get_app_id();
         cce_ui::engine::WindowSettings {
             title: "Status Interface".to_string(),
             app_id,
             width: self.width,
             height: self.height,
             fullscreen: false,
             min_size: None,
         }
     }
 
     fn desired_size(&self) -> Option<(u32, u32)> {
         if self.selected_module_name.is_some() {
             Some((self.width, self.height))
         } else {
             None
         }
     }
 
     fn update(&mut self, msg: Self::Message, needs_rebuild: &mut bool, _exit: &mut bool) {
         // Default to redrawing; the high-frequency push events below clear this when
         // their value is unchanged, so a once-a-second stats poll (or a repeated
         // title push) no longer forces a redraw — and the compositor's
         // whole-backdrop blur re-bake — every time.
         let mut changed = true;
         match msg {
             CustomEvent::LayoutUpdated(l) => {
                 // Nothing renders the mode in the strip anymore; it is read
                 // at menu-open time for the window module's menu row.
                 changed = false;
                 self.layout = l;
             }
             CustomEvent::TitleUpdated(t) => {
                 changed = self.title != t;
                 self.title = t;
             }
             CustomEvent::SystemStatsUpdated(mut s) => {
                 // Where the fast path runs, the poll does not read the
                 // backlight or the sink (`spawn_system_stats`): those two
                 // stay as the fast path last set them.
                 if has_fast_levels(self.selected_module_name.as_deref()) {
                     if let Some(old) = self.stats.as_ref() {
                         s.brightness = old.brightness;
                         s.volume = old.volume;
                     }
                 }
                 log::debug!("[module-{}] stats updated, current width={}", self.selected_module_name.as_deref().unwrap_or("none"), self.width);
                 let module = self.selected_module_name.as_deref();
                 match stats_signature(module, &s) {
                     // Module ignores stats (window/tray/light_source): never redraw here.
                     None => changed = false,
                     Some(new_sig) => {
                         let old_sig = self.stats.as_ref().and_then(|o| stats_signature(module, o));
                         changed = old_sig.as_deref() != Some(new_sig.as_str());
                     }
                 }
                 self.stats = Some(s);
             }
             CustomEvent::BrightnessUpdated(b) => {
                 log::debug!("[module-{}] fast-path brightness {:?}", self.selected_module_name.as_deref().unwrap_or("none"), b);
                 changed = paints_stat(self.selected_module_name.as_deref(), "brightness")
                     && self.stats.as_ref().is_some_and(|s| s.brightness != b);
                 if let Some(s) = self.stats.as_mut() {
                     s.brightness = b;
                 }
             }
             CustomEvent::VolumeUpdated(v) => {
                 log::debug!("[module-{}] fast-path volume {:?}", self.selected_module_name.as_deref().unwrap_or("none"), v);
                 changed = paints_stat(self.selected_module_name.as_deref(), "volume")
                     && self.stats.as_ref().is_some_and(|s| s.volume != v);
                 if let Some(s) = self.stats.as_mut() {
                     s.volume = v;
                 }
             }
             CustomEvent::TrayUpdated(item) => {
                 self.tray_items.insert(item.id.clone(), item);
             }
             CustomEvent::TrayRemoved(id) => {
                 self.tray_items.remove(&id);
             }
             CustomEvent::MenuReady { title, pages, min_w } => {
                 if !pages.is_empty() && !self.is_vertical() {
                     let _ = title;
                     if self.context_menu.is_none() {
                         self.menu_anim = 0.0;
                     }
                     self.menu_closing = false;
                     self.context_menu = Some(ModuleContextMenu {
                         pages,
                         page: 0,
                         tray_target: None,
                         min_w,
                         hovered: None,
                         rect: (0.0, 0.0, 0.0, 0.0),
                         row_bounds: Vec::new(),
                     });
                 } else {
                     changed = false;
                 }
             }
             CustomEvent::TrayMenuFetched { destination, menu_path, pages } => {
                 if !pages.is_empty() && !self.is_vertical() {
                     if self.context_menu.is_none() {
                         self.menu_anim = 0.0;
                     }
                     self.menu_closing = false;
                     self.context_menu = Some(ModuleContextMenu {
                         pages,
                         page: 0,
                         tray_target: Some((destination, menu_path)),
                         min_w: 260.0,
                         hovered: None,
                         rect: (0.0, 0.0, 0.0, 0.0),
                         row_bounds: Vec::new(),
                     });
                 } else {
                     changed = false;
                 }
             }
             CustomEvent::SwitcherTriggered => {
                 log::debug!("[switcher] SwitcherTriggered event received, calling trigger_switcher");
                 self.trigger_switcher(true);
             }
             CustomEvent::MenuDismiss(pressed_app_id) => {
                 // Close-on-click-away, unless the press was on THIS segment
                 // (then handle_mouse_input already decided what to do).
                 if self.context_menu.is_some()
                     && !self.menu_closing
                     && pressed_app_id != self.get_app_id()
                 {
                     self.menu_closing = true;
                 } else {
                     changed = false;
                 }
             }
             CustomEvent::ToggleHideModules => {
                 self.status_hide_mode = !self.status_hide_mode;
                 let cmd = if self.status_hide_mode { "true" } else { "false" };
                 if let Err(e) = std::process::Command::new(get_ccectl_cmd())
                     .args(["status-hide-mode", cmd])
                     .status()
                 {
                     log::warn!("[hide-mode] ccectl status-hide-mode failed: {:?}", e);
                 }
                 *needs_rebuild = true;
             }
             CustomEvent::ToggleAdjustPositionMode => {
                 // The compositor is the source of truth: sync to its state,
                 // then send the flipped value.
                 self.adjust_position_mode =
                     !query_adjust_position_mode().unwrap_or(self.adjust_position_mode);
                 let cmd = if self.adjust_position_mode { "true" } else { "false" };
                 if let Err(e) = std::process::Command::new(get_ccectl_cmd())
                     .args(["adjust-position-mode", cmd])
                     .status()
                 {
                     log::warn!("[adjust-mode] ccectl adjust-position-mode failed: {:?}", e);
                 }
                 *needs_rebuild = true;
             }
         }
         if changed {
             self.needs_rebuild = true;
             *needs_rebuild = true;
         }
     }
 
     fn tick(&mut self, dt: f32, needs_rebuild: &mut bool) {
         // Ease the drawn bubble toward its live-content width: stepping
         // straight there would snap the
         // bubble edges on every stat update or title change, and a flapping
         // browser title would make the box twitch instead of breathe.
         {
             const BUBBLE_EASE_S: f32 = 0.12;
             let target = self.bubble_w_target;
             if (target - self.bubble_w_now).abs() > 0.5 {
                 let step = (dt / BUBBLE_EASE_S).clamp(0.0, 1.0);
                 self.bubble_w_now += (target - self.bubble_w_now) * step;
                 *needs_rebuild = true;
                 self.needs_rebuild = true;
             } else if self.bubble_w_now != target && target > 0.0 {
                 self.bubble_w_now = target;
                 *needs_rebuild = true;
                 self.needs_rebuild = true;
             }
         }
 
         // In-surface menu expansion/contraction: the surface grows into the
         // menu and shrinks back over MENU_ANIM_S, one resize+repaint per
         // tick. The menu object is dropped only when the contraction lands.
         if self.context_menu.is_some() {
             const MENU_ANIM_S: f32 = 0.14;
             if self.menu_closing {
                 self.menu_anim -= dt / MENU_ANIM_S;
                 if self.menu_anim <= 0.0 {
                     self.menu_anim = 0.0;
                     self.menu_closing = false;
                     self.context_menu = None;
                 }
                 *needs_rebuild = true;
                 self.needs_rebuild = true;
             } else if self.menu_anim < 1.0 {
                 self.menu_anim = (self.menu_anim + dt / MENU_ANIM_S).min(1.0);
                 *needs_rebuild = true;
                 self.needs_rebuild = true;
             }
         }
 
         // Watches the shared config AND the app's own override file (the
         // newest mtime of the pair) — same key cce-ui's config cache uses.
         let modified = cce_ui::config::config_files_modified();
         if modified.is_some() && modified != self.last_config_modified {
             self.last_config_modified = modified;
             *needs_rebuild = true;
             self.needs_rebuild = true;
         }
     }
 
     // style-audit: opt-out the bar is a transparent surface; each module box is its own plate
 
     fn display_list(&mut self, size: cce_ui::engine::LogicalSize, scale: f64) -> Option<cce_ui::scene::paint::DisplayList> {
         // Phase 6ak single paint path: the rounded boxes, the status-bar bg / module rects
         // (the legacy view_rounded_quads then view() bodies, in the wrapper's
         // order), and the module text (prims, reshaped by the engine cache). overlay_quads
         // stays a separate on-top pass. The status bar's own text is never set in this app,
         // so it contributes only its background quad.
         use cce_ui::scene::layout::Rect;
         if self.needs_rebuild || self.width != size.width as u32 || self.height != size.height as u32 || self.scale_factor != scale {
             self.width = size.width as u32;
             self.height = size.height as u32;
             self.scale_factor = scale;
             cce_ui::scale::set_scale_factor(scale as f32);
             self.rebuild_layout();
         }
         let mut pc = cce_ui::scene::paint::PaintCtx::new();
 
         // Droplet-style module boxes paint first, so any remaining rounded
         // boxes (module-internal chips) and all content sit on the drops.
         for &(x, y, w, h, color, spec) in &self.droplet_boxes {
             pc.droplet(Rect { x, y, width: w, height: h }, &cce_ui::scene::Material::from_fill(color).with_finish(spec.finish()), spec);
         }
 
         for rb in &self.rounded_boxes {
             let rect = Rect { x: rb.x, y: rb.y, width: rb.w, height: rb.h };
             // Same positional corner→radius mapping the RoundedRect prim uses.
             let radii = (
                 if rb.corners.0 { rb.radius } else { 0.0 },
                 if rb.corners.1 { rb.radius } else { 0.0 },
                 if rb.corners.2 { rb.radius } else { 0.0 },
                 if rb.corners.3 { rb.radius } else { 0.0 },
             );
             // True-shape boxes (the light module's circle): no bevel
             // treatment. A full circle draws through the Circle/Arc prims —
             // the rounded-rect corner family is the squircle (corner_shape),
             // which reads as a rounded SQUARE at half-extent radius — with
             // the fill and stroke each optional. Anything else outlined goes
             // through the Border prim (fill + stroke).
             if let Some((border_color, thickness)) = rb.border {
                 if (rb.w - rb.h).abs() < 0.5 && (rb.radius - rb.w / 2.0).abs() < 0.5 {
                     let r = rb.w / 2.0;
                     if rb.color[3] > 0.001 {
                         // With raised module boxes (lit plates), the circle
                         // takes the sphere-lit disc — the circular sibling of
                         // the plate treatment, same light and material.
                         if matches!(self.box_bevel, Some(StatusBoxBevel::Raised)) {
                             pc.sphere(rb.x + r, rb.y + r, r, &cce_ui::scene::Material::from_fill(rb.color));
                         } else {
                             pc.circle(rb.x + r, rb.y + r, r, rb.color);
                         }
                     }
                     if thickness > 0.05 {
                         pc.arc(rb.x + r, rb.y + r, r, thickness, 0.0, std::f32::consts::TAU, border_color);
                     }
                 } else {
                     pc.border(rect, radii, rb.color, border_color, thickness);
                 }
                 continue;
             }
             match self.box_bevel {
                 Some(StatusBoxBevel::Raised) => {
                     // A lit plate: fill + rolled lip in one prim.
                     pc.bevel(rect, radii, &cce_ui::scene::Material::from_fill(rb.color), self.box_bevel_depth);
                 }
                 Some(StatusBoxBevel::Inset) => {
                     // Recess shades only the rim, so keep the flat fill under it.
                     if rb.radius > 0.1 {
                         pc.rounded_rect(rect, rb.radius, rb.corners, rb.color);
                     } else {
                         pc.quad(rect, rb.color);
                     }
                     pc.recess(rect, radii, self.box_bevel_depth);
                 }
                 None => {
                     if rb.radius > 0.1 {
                         pc.rounded_rect(rect, rb.radius, rb.corners, rb.color);
                     } else {
                         pc.quad(rect, rb.color);
                     }
                 }
             }
         }
 
         let (sb_x, sb_y, sb_w, sb_h) = self.status_bar.rect();
         pc.quad(Rect { x: sb_x, y: sb_y, width: sb_w, height: sb_h }, self.status_bar.color());
         for r in &self.rects {
             pc.quad(Rect { x: r.x, y: r.y, width: r.w, height: r.h }, r.color);
         }
 
         // The hovered menu row's pill, pre-text so the label sits on it.
         if let Some((hx, hy, hw, hh)) = self.menu_hover_rect {
             pc.rounded_rect(
                 Rect { x: hx, y: hy, width: hw, height: hh },
                 (hh / 2.0).min(8.0),
                 (true, true, true, true),
                 [0.23, 0.35, 0.50, 0.55],
             );
         }
 
         // Readout glyphs, under the numbers beside them.
         for ip in &self.icon_prims {
             pc.image(ip.image, Rect { x: ip.x, y: ip.y, width: ip.w, height: ip.h }, ip.alpha);
         }
 
         for (text, tsize, x, y, color, font, bounds, layout, weight) in &self.text_prims {
             let attrs = cce_ui::scene::paint::TextAttrs { italic: false, weight: *weight, ..Default::default() };
             match layout {
                 Some(l) => pc.text_boxed(text.clone(), *x, *y, *tsize, *color, font.clone(), *bounds, attrs, *l),
                 // Glyphs are drawn plain: contrast is the compositor's job,
                 // which compresses the backdrop behind the segment
                 // (`module { backdrop_compress }`).
                 None => pc.text_attrs(text.clone(), *x, *y, *tsize, *color, font.clone(), *bounds, attrs),
             }
         }
 
         Some(pc.finish())
     }
 
     /// A reconnect is a new session around the SAME app (cce-ui's
     /// `window_runner` repairs a lost transport rather than restarting the
     /// process), and the renderer is rebuilt with it — so the glyph ids the
     /// retained `icon_prims` hold name nothing. A draw for an unknown image
     /// id is skipped silently, which is why a reconnected bar once kept its
     /// numbers and lost every glyph. The upload cache follows the renderer
     /// epoch by itself (`icons::glyph`); rebuilding the layout is what asks
     /// it again, uploading into the renderer just created.
     fn renderer_init(&mut self, _renderer: &mut cce_ui::vk::VkRenderer) {
         if std::mem::replace(&mut self.seen_renderer, true) {
             self.needs_rebuild = true;
         }
     }
 
     fn display_list_text(&self) -> bool {
         true
     }
 
     fn overlay_quads(&mut self, quads: &mut Vec<(f32, f32, f32, f32, [f32; 4])>, _size: cce_ui::engine::LogicalSize, _scale: f64) {
         for r in &self.overlay_rects {
             quads.push((r.x, r.y, r.w, r.h, r.color));
         }
     }
 
     fn clear_color(&self) -> [f32; 4] {
         [0.0, 0.0, 0.0, 0.0]
     }
 
     fn input_regions(&self) -> Option<Vec<(i32, i32, i32, i32)>> {
         Some(self.input_regions.clone())
     }
 
     fn handle_pointer_move(&mut self, pos: cce_ui::engine::LogicalPosition, needs_rebuild: &mut bool) {
         if let Some(menu) = &mut self.context_menu {
             let hovered = menu.item_at(pos.x, pos.y);
             if hovered != menu.hovered {
                 menu.hovered = hovered;
                 *needs_rebuild = true;
                 self.needs_rebuild = true;
             }
         }
         let (lx, ly) = (pos.x, pos.y);
         self.cursor_pos = (lx as f64, ly as f64);
 
         let mut newly_hovered = None;
         for bound in &self.tray_item_bounds {
             if lx >= bound.x && lx <= (bound.x + bound.w)
                 && ly >= bound.y && ly <= (bound.y + bound.h) {
                 newly_hovered = Some(bound.id.clone());
                 break;
             }
         }
         if self.hovered_tray_item != newly_hovered {
             self.hovered_tray_item = newly_hovered;
             *needs_rebuild = true;
             self.needs_rebuild = true;
         }
     }
 
     fn handle_mouse_input(&mut self, button: MouseButton, state: ElementState, pos: cce_ui::engine::LogicalPosition, needs_rebuild: &mut bool) -> Option<Self::Message> {
         let (lx, ly) = (pos.x, pos.y);
         let is_vertical = self.is_vertical();
         let coord = if is_vertical { ly } else { lx };
         let cx = lx as f64;
         let cy = ly as f64;
 
         // An open in-surface menu owns every button event: row clicks run
         // their action (dispatch / DBusMenu event / page navigation); any
         // other press (bar strip, menu padding, right-click) closes.
         if let Some(menu) = self.context_menu.as_mut() {
             if state != ElementState::Pressed {
                 return None;
             }
             // A menu animating shut is already spoken for — its rows are
             // sliding away, so presses neither re-trigger nor re-open.
             if self.menu_closing {
                 return None;
             }
             let hit = if button == MouseButton::Left { menu.item_at(lx, ly) } else { None };
             let mut result = None;
             match hit {
                 Some(i) => {
                     let action = menu.rows().get(i).map(|r| r.action.clone());
                     match action {
                         Some(MenuRowAction::Dispatch(ev)) => {
                             self.menu_closing = true;
                             result = Some(ev);
                         }
                         Some(MenuRowAction::Item(id)) => {
                             if let Some((dest, path)) = menu.tray_target.clone() {
                                 send_tray_menu_event(dest, path, id);
                             }
                             self.menu_closing = true;
                         }
                         Some(MenuRowAction::Submenu(p)) | Some(MenuRowAction::Back(p)) => {
                             menu.page = p;
                             menu.hovered = None;
                         }
                         Some(MenuRowAction::Ccectl(args)) => {
                             std::thread::spawn(move || {
                                 let _ = std::process::Command::new(get_ccectl_cmd())
                                     .args(&args)
                                     .spawn();
                             });
                             self.menu_closing = true;
                         }
                         _ => {}
                     }
                 }
                 None => {
                     self.menu_closing = true;
                 }
             }
             self.needs_rebuild = true;
             *needs_rebuild = true;
             return result;
         }
 
         if state == ElementState::Pressed {
             // Check if tray icon was clicked
             let mut clicked_tray = None;
             for bound in &self.tray_item_bounds {
                 if cx >= bound.x as f64 && cx <= (bound.x + bound.w) as f64
                     && cy >= bound.y as f64 && cy <= (bound.y + bound.h) as f64 {
                     clicked_tray = Some(bound.clone());
                     break;
                 }
             }
 
             if let Some(bound) = clicked_tray {
                 let id = bound.id.clone();
                 let btn_code = match button {
                     MouseButton::Left => 272,
                     MouseButton::Right => 273,
                     _ => 0,
                 };
                 let local = (cx as i32, cy as i32);
                 let segment_app_id = self.get_app_id();
                 let thread_sender = self.sender.clone();
                 std::thread::spawn(move || {
                     // Off the UI thread: this asks the compositor.
                     let (cx_i, cy_i) =
                         tray_click_point(segment_screen_rect(&segment_app_id), local.0, local.1);
                     let rt = tokio::runtime::Builder::new_current_thread()
                         .enable_all()
                         .build()
                         .unwrap();
                     rt.block_on(async move {
                         if let Some((destination, path_part)) = id.split_once('/') {
                             let path = format!("/{}", path_part);
                             match zbus::Connection::session().await {
                                 Ok(conn) => {
                                     match StatusNotifierItemProxy::builder(&conn)
                                         .destination(destination.to_string())
                                         .unwrap()
                                         .path(path)
                                         .unwrap()
                                         .build()
                                         .await
                                     {
                                         Ok(proxy) => {
                                             let is_menu = proxy.item_is_menu().await.unwrap_or(false);
                                             let menu_path = proxy.menu().await.ok();
 
                                             let should_show_menu = (btn_code == 273 && menu_path.is_some())
                                                 || (btn_code == 272 && is_menu && menu_path.is_some());
 
                                             // In-surface menu: fetch the DBusMenu layout and hand
                                             // it to the module's update loop — the tray segment's
                                             // own surface expands to show it (no popup process).
                                             if should_show_menu {
                                                 if let Some(menu_p) = menu_path {
                                                     match fetch_tray_menu_pages(&conn, destination, menu_p.as_str()).await {
                                                         Ok(pages) if !pages.is_empty() => {
                                                             let _ = thread_sender.send(CustomEvent::TrayMenuFetched {
                                                                 destination: destination.to_string(),
                                                                 menu_path: menu_p.as_str().to_string(),
                                                                 pages,
                                                             });
                                                         }
                                                         Ok(_) => log::debug!("[tray-menu] empty menu for {}", destination),
                                                         Err(e) => log::warn!("[tray-menu] fetch failed: {:?}", e),
                                                     }
                                                 }
                                             } else if btn_code == 272 {
                                                 if let Err(e) = proxy.activate(cx_i, cy_i).await {
                                                     log::warn!("[tray-click] Activate failed: {:?}", e);
                                                     if let Some(menu_p) = menu_path {
                                                         if let Ok(pages) = fetch_tray_menu_pages(&conn, destination, menu_p.as_str()).await {
                                                             if !pages.is_empty() {
                                                                 let _ = thread_sender.send(CustomEvent::TrayMenuFetched {
                                                                     destination: destination.to_string(),
                                                                     menu_path: menu_p.as_str().to_string(),
                                                                     pages,
                                                                 });
                                                             }
                                                         }
                                                     }
                                                 }
                                             } else if btn_code == 273 {
                                                 let _ = proxy.context_menu(cx_i, cy_i).await;
                                             }
                                         }
                                         Err(e) => log::warn!("[tray-click] Failed to build proxy: {:?}", e),
                                     }
                                 }
                                 Err(e) => log::warn!("[tray-click] Failed to connect to session bus: {:?}", e),
                             }
                         } else {
                             log::warn!("[tray-click] Failed to split id: {}", id);
                         }
                     });
                 });
                 return None;
             }
 
             if button == MouseButton::Right {
                 self.adjust_position_mode =
                     query_adjust_position_mode().unwrap_or(self.adjust_position_mode);
                 // Find which module was right-clicked
                 let mut clicked_module = None;
                 for mb in &self.module_bounds {
                     if coord >= mb.x && coord <= (mb.x + mb.w) {
                         clicked_module = Some(mb.clone());
                         break;
                     }
                 }
 
                 if let Some(mb) = clicked_module {
                     if is_vertical {
                         // v1: the in-surface menu only lays out on horizontal
                         // segments.
                         return None;
                     }
                     log::debug!("[module-right-click] opening in-surface menu for: {}", mb.name);
                     if self.context_menu.is_none() {
                         self.menu_anim = 0.0;
                     }
                     self.menu_closing = false;
                     let dispatch_row = |label: &str, ev: CustomEvent| MenuRow {
                         label: label.to_string(),
                         enabled: true,
                         separator: false,
                         action: MenuRowAction::Dispatch(ev),
                     };
                     let mut rows = if self.adjust_position_mode {
                         vec![dispatch_row("Done", CustomEvent::ToggleAdjustPositionMode)]
                     } else {
                         vec![
                             dispatch_row(
                                 if self.status_hide_mode { "Show Modules" } else { "Hide Modules" },
                                 CustomEvent::ToggleHideModules,
                             ),
                             dispatch_row("Adjust Positions", CustomEvent::ToggleAdjustPositionMode),
                         ]
                     };
                     // The light module's strip presence is just the empty
                     // circle; its value lives here in the menu.
                     if mb.name == "light_source" {
                         rows.insert(0, MenuRow {
                             label: format!("{:.2} rad", modules::get_light_source_pos_from_config()),
                             enabled: true,
                             separator: false,
                             action: MenuRowAction::Inert,
                         });
                     }
                     // The window module's strip shows only the title; the
                     // focused window's mode lives here in its menu — as a
                     // dropdown when the mode is one a user may set, opening
                     // a submenu page whose rows run `ccectl set-mode <mode>`
                     // on the focused window (status segments never take seat
                     // focus, so "focused" is still the real window).
                     let mut extra_pages: Vec<MenuPage> = Vec::new();
                     if mb.name == "window" && !self.layout.is_empty() {
                         const MODES: [&str; 3] = ["Floating", "Tiled", "Fullscreen"];
                         if MODES.contains(&self.layout.as_str()) {
                             // Page 0 is the root built below; the mode page is
                             // the only extra, so it is always page 1.
                             rows.insert(0, MenuRow {
                                 label: self.layout.clone(),
                                 enabled: true,
                                 separator: false,
                                 action: MenuRowAction::Submenu(1),
                             });
                             let mut mode_rows = vec![cloud::back_row(0)];
                             for mode in MODES {
                                 let current = mode == self.layout;
                                 // A radio group: the toolkit's on and off
                                 // marks, drawn as the circle glyphs.
                                 let mark = if current {
                                     cce_ui::widget::context_menu::MARK_ON
                                 } else {
                                     cce_ui::widget::context_menu::MARK_OFF
                                 };
                                 mode_rows.push(MenuRow {
                                     label: format!("{mark}{mode}"),
                                     // The current mode is a marker, not a
                                     // target — disabled rows never match a
                                     // click.
                                     enabled: !current,
                                     separator: false,
                                     action: MenuRowAction::Ccectl(vec![
                                         "set-mode".to_string(),
                                         mode.to_lowercase(),
                                     ]),
                                 });
                             }
                             extra_pages.push(MenuPage { title: "Mode".to_string(), rows: mode_rows });
                         } else {
                             // Internal roles (Popup/Overlay/Status/Utility)
                             // and the no-focus "---" stay a plain readout.
                             rows.insert(0, MenuRow {
                                 label: self.layout.clone(),
                                 enabled: true,
                                 separator: false,
                                 action: MenuRowAction::Inert,
                             });
                         }
                     }
                     let mut pages = vec![MenuPage { title: mb.name.clone(), rows }];
                     pages.extend(extra_pages);
                     self.context_menu = Some(ModuleContextMenu {
                         pages,
                         page: 0,
                         tray_target: None,
                         min_w: 190.0,
                         hovered: None,
                         rect: (0.0, 0.0, 0.0, 0.0),
                         row_bounds: Vec::new(),
                     });
                     self.needs_rebuild = true;
                     *needs_rebuild = true;
                     return None;
                 }
             }
 
             if button == MouseButton::Left {
                 let mut clicked_window = false;
                 for mb in &self.module_bounds {
                     if mb.name == "window"
                         && coord >= mb.x && coord <= (mb.x + mb.w) {
                             clicked_window = true;
                             break;
                         }
                 }
 
                 if clicked_window {
                     log::debug!("[window-click] Window module clicked, opening window picker");
                     self.trigger_switcher(false);
                 }
             }
         }
         None
     }
 
     fn handle_mouse_wheel(&mut self, _delta: &MouseScrollDelta, _pos: cce_ui::engine::LogicalPosition, _needs_rebuild: &mut bool) {}
 
     fn handle_key_input(&mut self, _event: &KeyEvent, _needs_rebuild: &mut bool) -> Option<Self::Message> { None }
 }
 
 
 
 
 
 
 
 
 fn main() {
     // Info by default; RUST_LOG (e.g. =debug) takes precedence when set.
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
 
     let args: Vec<String> = std::env::args().collect();
     log::info!("cce-status-interface started with args = {:?}", args);
     if args.len() > 1 && args[1] == "--trigger-switcher" {
         let rt = tokio::runtime::Runtime::new().expect("tokio runtime");
         rt.block_on(async {
             let display = std::env::var("WAYLAND_DISPLAY").unwrap_or_else(|_| "wayland-0".to_string());
             let socket_path = format!("/tmp/cce-status-interface-switcher-{}.sock", display);
             use tokio::io::AsyncWriteExt;
             if let Ok(mut stream) = tokio::net::UnixStream::connect(&socket_path).await {
                 let _ = stream.write_all(b"trigger\n").await;
             }
         });
         return;
     }
 
     if args.len() > 1 && args[1] == "--osd" {
         osd::main(&args[2..]);
         return;
     }
 
     let has_module = args.iter().any(|arg| arg == "--module");
 
     if !has_module {
         log::info!("Starting cce-status-interface launcher daemon...");
         let rt = small_runtime();
         rt.block_on(async {
             use tokio::signal::unix::{signal, SignalKind};
             let mut sigint = signal(SignalKind::interrupt()).expect("SIGINT");
             let mut sigterm = signal(SignalKind::terminate()).expect("SIGTERM");
             // Before any module is spawned, so an early exit is not missed.
             let mut sigchld = signal(SignalKind::child()).expect("SIGCHLD");
             
             // `stats` is the combined readout segment (cpu, memory,
             // brightness, volume, wifi, battery in one bubble); the six single
             // names remain valid `--module` values but are not launched.
             let modules = vec!["window", "tray", "stats", "clock", "light_source"];
             let current_exe = std::env::current_exe().unwrap_or_else(|_| {
                 std::path::PathBuf::from(std::env::var("HOME").unwrap_or_default())
                     .join(".local/bin/cce-status-interface")
             });
 
             // Restart crashed modules with exponential backoff: a module
             // that keeps dying quickly waits longer each time (up to
             // RESTART_MAX) instead of respawning twice a second; a run of
             // HEALTHY_UPTIME resets its backoff.
             const RESTART_BASE: std::time::Duration = std::time::Duration::from_millis(500);
             const RESTART_MAX: std::time::Duration = std::time::Duration::from_secs(30);
             const HEALTHY_UPTIME: std::time::Duration = std::time::Duration::from_secs(30);
 
             struct Supervised {
                 child: Option<std::process::Child>,
                 spawned_at: std::time::Instant,
                 backoff: std::time::Duration,
                 restart_at: std::time::Instant,
             }
 
             let spawn_module = |module: &str| {
                 std::process::Command::new(&current_exe)
                     .arg("--module")
                     .arg(module)
                     .spawn()
             };
 
             // The volume/brightness slider is not a supervised module: it
             // is started per change and exits on its own (`osd.rs`).
             osd::spawn_trigger(current_exe.clone()).await;
 
             let mut supervised: std::collections::HashMap<String, Supervised> = std::collections::HashMap::new();
 
             for module in &modules {
                 let now = std::time::Instant::now();
                 let child = match spawn_module(module) {
                     Ok(c) => {
                         log::info!("Spawned module process for: {}", module);
                         Some(c)
                     }
                     Err(e) => {
                         log::error!("Failed to spawn module process for {}: {:?}", module, e);
                         None
                     }
                 };
                 supervised.insert(module.to_string(), Supervised {
                     child,
                     spawned_at: now,
                     backoff: RESTART_BASE,
                     restart_at: now + RESTART_BASE,
                 });
             }
 
             loop {
                 let next_restart = supervised
                     .values()
                     .filter(|e| e.child.is_none())
                     .map(|e| e.restart_at)
                     .min();
                 tokio::select! {
                     _ = sigint.recv() => {
                         log::info!("Received SIGINT, shutting down...");
                         break;
                     }
                     _ = sigterm.recv() => {
                         log::info!("Received SIGTERM, shutting down...");
                         break;
                     }
                     // A module exited — or any child: the slider, a `pactl` —
                     // or a held-back restart is due. Until 2026-10-05 this
                     // woke every 500 ms to `try_wait` each module.
                     _ = sigchld.recv() => {}
                     _ = async {
                         match next_restart {
                             Some(t) => tokio::time::sleep_until(tokio::time::Instant::from_std(t)).await,
                             None => std::future::pending().await,
                         }
                     } => {}
                 }
                 let now = std::time::Instant::now();
                 for module in &modules {
                     let Some(entry) = supervised.get_mut(*module) else { continue };
 
                     if let Some(child) = entry.child.as_mut() {
                         match child.try_wait() {
                             Ok(None) => continue,
                             Ok(Some(status)) => {
                                 entry.child = None;
                                 if entry.spawned_at.elapsed() >= HEALTHY_UPTIME {
                                     entry.backoff = RESTART_BASE;
                                 } else {
                                     entry.backoff = (entry.backoff * 2).min(RESTART_MAX);
                                 }
                                 entry.restart_at = now + entry.backoff;
                                 log::warn!(
                                     "Module process '{}' exited with status: {:?}. Restarting in {:?}...",
                                     module, status, entry.backoff
                                 );
                             }
                             Err(e) => {
                                 log::error!("Error checking status for module '{}': {:?}", module, e);
                                 continue;
                             }
                         }
                     }
 
                     if now >= entry.restart_at {
                         match spawn_module(module) {
                             Ok(c) => {
                                 log::info!("Restarted module process for: {}", module);
                                 entry.child = Some(c);
                                 entry.spawned_at = now;
                             }
                             Err(e) => {
                                 entry.backoff = (entry.backoff * 2).min(RESTART_MAX);
                                 entry.restart_at = now + entry.backoff;
                                 log::error!(
                                     "Failed to restart module process for {}: {:?}. Retrying in {:?}...",
                                     module, e, entry.backoff
                                 );
                             }
                         }
                     }
                 }
             }
 
             for (module, entry) in supervised {
                 if let Some(mut child) = entry.child {
                     log::info!("Killing module process: {}", module);
                     let _ = child.kill();
                 }
             }
         });
         return;
     }
 
     let rt = small_runtime();
     let _guard = rt.enter();
 
     cce_ui::engine::run::<StatusApp>();
 }
 
 /// The runtime for the launcher and every module process: a few sockets, a
 /// timer and a `pactl` pipe, so two workers. `Runtime::new()` starts one per
 /// core — twenty here, in each of the bar's six processes — and a timer tick
 /// on a runtime that wide wakes idle workers to look for work to steal.
 fn small_runtime() -> tokio::runtime::Runtime {
     tokio::runtime::Builder::new_multi_thread()
         .worker_threads(2)
         .enable_all()
         .build()
         .expect("tokio runtime")
 }
 
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     /// The bar's menus draw their marks and page turns as cce-icons glyphs,
     /// by the toolkit's context-menu conventions, and never spell them as
     /// characters: a DBusMenu toggle becomes a leading mark, a submenu row
     /// ends in chevron-right, a back row starts with chevron-left.
     #[test]
     fn menu_marks_and_page_turns_are_glyphs() {
         use cce_ui::widget::context_menu::{MARK_CHECK, MARK_OFF, MARK_ON};
         assert_eq!(toggle_mark("checkmark", 1), MARK_CHECK);
         assert_eq!(toggle_mark("checkmark", 0), "");
         assert_eq!(toggle_mark("radio", 1), MARK_ON);
         assert_eq!(toggle_mark("radio", 0), MARK_OFF);
         assert_eq!(toggle_mark("", -1), "");
 
         let row = |label: &str, action: MenuRowAction| MenuRow {
             label: label.to_string(),
             enabled: true,
             separator: false,
             action,
         };
         assert_eq!(
             menu_row_glyphs(&row(&format!("{MARK_CHECK}Sync"), MenuRowAction::Item(3))),
             (Some("check"), "Sync", None)
         );
         assert_eq!(
             menu_row_glyphs(&row("Tiled", MenuRowAction::Submenu(1))),
             (None, "Tiled", Some("chevron-right"))
         );
         assert_eq!(menu_row_glyphs(&back_row(0)), (Some("chevron-left"), "Back", None));
         assert_eq!(menu_row_glyphs(&row("Quit", MenuRowAction::Item(9))), (None, "Quit", None));
     }
 
     /// A tray item with no icon of its own stands in a cce-icons glyph,
     /// guessed from its icon name, and every one it can name is in the set.
     #[test]
     fn a_tray_item_without_an_icon_is_a_glyph() {
         use modules::tray_fallback_glyph as g;
         assert_eq!(g(None), "gear");
         assert_eq!(g(Some("audio-volume-muted")), "volume-muted");
         assert_eq!(g(Some("audio-volume-high")), "volume");
         assert_eq!(g(Some("network-wireless")), "wifi");
         assert_eq!(g(Some("battery-full")), "battery");
         assert_eq!(g(Some("bluetooth-active")), "bluetooth");
         assert_eq!(g(Some("mail-unread")), "mail");
         assert_eq!(g(Some("discord")), "chat");
         assert_eq!(g(Some("steam_tray_mono")), "gamepad");
         assert_eq!(g(Some("dropboxstatus-idle")), "cube");
         assert_eq!(g(Some("something-else")), "gear");
         // The workspace's own icon set, where the build has it.
         let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../cce-icons/svg");
         if dir.is_dir() {
             for name in ["gear", "volume-muted", "volume", "wifi", "battery", "bluetooth", "mail", "chat",
                 "gamepad", "cube", "check", "circle", "circle-outline", "chevron-left", "chevron-right"] {
                 assert!(dir.join(format!("{name}.svg")).is_file(), "{name}.svg is not in cce-icons");
             }
         }
     }
 
     #[test]
     fn tray_clicks_report_screen_points_below_the_bar() {
         let listing = concat!(
             r#"{"app_id":"cce-status-interface-right-clock","x":1569,"y":0,"w":339,"h":27}"#, "\n",
             r#"{"app_id":"cce-status-interface-right-tray","x":1127,"y":0,"w":116,"h":27}"#, "\n",
         );
         let seg = segment_rect_in(listing, "cce-status-interface-right-tray");
         assert_eq!(seg, Some((1127, 0, 27)));
         assert_eq!(tray_click_point(seg, 40, 12), (1167, 27));
         assert_eq!(segment_rect_in(listing, "cce-status-interface-left-window"), None);
         assert_eq!(tray_click_point(None, 40, 12), (40, 12));
     }
 
     // ------------------------------------------------------------------
     // The expanded menu's drop: the module box grows downward, and the
     // silhouette must not grow with it.
     // ------------------------------------------------------------------
 
     /// The collapsed drop on a 27px bar, and a 10-row window picker.
     const COLLAPSED: (f32, f32) = (90.0, 21.0);
     const PICKER: (f32, f32) = (320.0, 339.0);
 
     #[test]
     fn an_expanded_drop_keeps_the_silhouette_it_had_collapsed() {
         // The whole point: same taper, same bottom corners, same bow, in
         // PIXELS, on a box sixteen times taller. Asserted through
         // resolve_silhouette rather than on the knobs, because that is the
         // function whose answer the shader actually draws.
         let spec = cce_ui::scene::paint::DropletSpec::default();
         let (sr0, ar0, bow0) = spec.resolve_silhouette(COLLAPSED.0, COLLAPSED.1);
         let grown = spec_at_reference_height(spec, COLLAPSED.1, PICKER.1);
         let (sr1, ar1, bow1) = grown.resolve_silhouette(PICKER.0, PICKER.1);
         for (a, b, what) in [(sr0, sr1, "sheet_r"), (ar0, ar1, "attach"), (bow0, bow1, "bow")] {
             assert!((a - b).abs() < 0.5, "{} drifted: {} vs {}", what, a, b);
         }
     }
 
     #[test]
     fn the_unscaled_spec_is_what_made_the_backdrop_miss_its_rows() {
         // The regression this guards. Left alone, the height fractions put
         // the picker's bottom radius on the half-width clamp — a literal
         // semicircle — with the rows laid out as a rectangle inside it.
         let spec = cce_ui::scene::paint::DropletSpec::default();
         let (sr, ar, _) = spec.resolve_silhouette(PICKER.0, PICKER.1);
         assert_eq!(sr, PICKER.0 / 2.0, "expected the half-width clamp");
         assert!(ar > PICKER.1 * 0.4, "expected the taper to eat the box");
     }
 
     #[test]
     fn a_box_no_taller_than_the_reference_is_left_exactly_alone() {
         // Every collapsed module box takes this path, and the expansion
         // animation starts here — so it has to be the identity, or the drop
         // pops on the first frame of opening.
         let spec = cce_ui::scene::paint::DropletSpec::default();
         assert_eq!(spec_at_reference_height(spec, COLLAPSED.1, COLLAPSED.1), spec);
         assert_eq!(spec_at_reference_height(spec, COLLAPSED.1, COLLAPSED.1 - 5.0), spec);
         assert_eq!(spec_at_reference_height(spec, 0.0, PICKER.1), spec);
     }
 
     #[test]
     fn only_the_knobs_measured_in_height_are_rescaled() {
         // The material and the exponents have no length in them: rescaling
         // `curve` would change the corner family, `shadow` the contact cue.
         let spec = cce_ui::scene::paint::DropletSpec::default();
         let grown = spec_at_reference_height(spec, COLLAPSED.1, PICKER.1);
         assert_eq!(grown.curve, spec.curve);
         assert_eq!(grown.core, spec.core);
         assert_eq!(grown.clarity, spec.clarity);
         assert_eq!(grown.shine, spec.shine);
         assert_eq!(grown.rim, spec.rim);
         assert_eq!(grown.shadow, spec.shadow);
         // belly_w is a fraction of the remaining half-WIDTH, not of height.
         assert_eq!(grown.belly_w, spec.belly_w);
         assert!(grown.sheet_r < spec.sheet_r);
     }
 
     #[test]
     fn the_expanded_panel_is_a_flat_sheet_with_the_water_terms_kept() {
         // The dome and its gleam fade OUT as the box grows: at full strength
         // the SDF-gradient dome draws a blocky lit frame (band pinned) or
         // envelope folds (band grown) on a long-sided panel — both tried,
         // both read as broken lighting. A real menu (k well under 0.5) lands
         // at exactly zero: flat glass, keeping clarity, rim, core, shadow.
         let spec = cce_ui::scene::paint::DropletSpec::default();
         let grown = spec_at_reference_height(spec, COLLAPSED.1, PICKER.1);
         assert_eq!(grown.dome, 0.0);
         assert_eq!(grown.gleam, 0.0);
         assert_eq!(grown.clarity, spec.clarity);
         assert_eq!(grown.rim, spec.rim);
 
         // The fade is CONTINUOUS in the growth factor — the expansion
         // animation passes through every k on its way down, so a step
         // anywhere would pop mid-flight. Just past the reference it is
         // near-identity; by twice the reference it has reached zero.
         let barely = spec_at_reference_height(spec, COLLAPSED.1, COLLAPSED.1 + 0.5);
         assert!((barely.dome - spec.dome).abs() < 0.1);
         let doubled = spec_at_reference_height(spec, COLLAPSED.1, COLLAPSED.1 * 2.0);
         assert_eq!(doubled.dome, 0.0);
     }
 
     // ------------------------------------------------------------------
     // Characterization tests (phase 0): these pin down current behavior
     // before the refactors in PROPOSAL.md. Where the behavior is odd, the
     // test documents it rather than fixing it. The config-lookup and color
     // tests moved to config.rs with the phase-2 rewrite.
     // ------------------------------------------------------------------
 
 
 
     // --- module_side_from_json ---
 
     fn side_cfg(name: &str, value: &str) -> serde_json::Value {
         serde_json::json!({"layout": {"status_bar": {name: value}}})
     }
 
     #[test]
     fn module_side_explicit_values() {
         assert_eq!(module_side_from_json(&side_cfg("clock", "left"), "clock"), Side::Left);
         assert_eq!(module_side_from_json(&side_cfg("window", "right"), "window"), Side::Right);
     }
 
     #[test]
     fn module_side_snap_aliases() {
         for (snap, side) in [
             ("top-left", Side::Left),
             ("bottom-left", Side::Left),
             ("top-center", Side::Left),
             ("bottom-center", Side::Left),
             ("top-right", Side::Right),
             ("bottom-right", Side::Right),
             ("TOP-LEFT", Side::Left), // case-insensitive
         ] {
             assert_eq!(module_side_from_json(&side_cfg("cpu", snap), "cpu"), side, "snap {}", snap);
         }
     }
 
     #[test]
     fn module_side_only_canonical_location_resolves() {
         // Only `layout { status_bar <name>=... }` counts; a same-named key
         // anywhere else is ignored (the fuzzy search is gone).
         let val = serde_json::json!({"stray": {"clock": "left"}});
         assert_eq!(module_side_from_json(&val, "clock"), Side::Right);
     }
 
     #[test]
     fn module_side_defaults() {
         let val = serde_json::json!({});
         assert_eq!(module_side_from_json(&val, "window"), Side::Left);
         assert_eq!(module_side_from_json(&val, "clock"), Side::Right);
         assert_eq!(module_side_from_json(&val, "tray"), Side::Right);
     }
 
     #[test]
     fn module_side_unknown_value_falls_through_to_default() {
         assert_eq!(module_side_from_json(&side_cfg("window", "sideways"), "window"), Side::Left);
         assert_eq!(module_side_from_json(&side_cfg("clock", "sideways"), "clock"), Side::Right);
     }
 
     #[test]
     fn module_side_light_source_from_angle() {
         // Left iff angle (rad) in [5π/8, 11π/8); default 135° is Left.
         let mk = |v: serde_json::Value| serde_json::json!({"window_manager": {"light_source_position": v}});
         assert_eq!(module_side_from_json(&serde_json::json!({}), "light_source"), Side::Left);
         // Float values are radians.
         assert_eq!(
             module_side_from_json(&mk(serde_json::json!(std::f64::consts::PI)), "light_source"),
             Side::Left
         );
         assert_eq!(module_side_from_json(&mk(serde_json::json!(0.0)), "light_source"), Side::Right);
         // Values > 2π are degrees (int or float), otherwise radians.
         assert_eq!(module_side_from_json(&mk(serde_json::json!(180)), "light_source"), Side::Left);
         assert_eq!(module_side_from_json(&mk(serde_json::json!(135.0)), "light_source"), Side::Left);
         assert_eq!(module_side_from_json(&mk(serde_json::json!(3)), "light_source"), Side::Left);
         assert_eq!(module_side_from_json(&mk(serde_json::json!(0)), "light_source"), Side::Right);
     }
 
     // --- parse_ccectl_windows ---
 
     #[test]
     fn ccectl_windows_full_line() {
         let out = parse_ccectl_windows(
             "window id=3 app_id=firefox title=\"Mozilla Firefox\" focused=true\n\
              window id=7 app_id=kitty title=\"~\" focused=false",
         );
         assert_eq!(out.len(), 2);
         assert_eq!(out[0], ("3".into(), "firefox".into(), "Mozilla Firefox".into(), true));
         assert_eq!(out[1], ("7".into(), "kitty".into(), "~".into(), false));
     }
 
     #[test]
     fn ccectl_windows_missing_required_fields_skips_line() {
         // No app_id → skipped; no window id → skipped.
         assert!(parse_ccectl_windows("window id=3 title=\"x\"").is_empty());
         assert!(parse_ccectl_windows("app_id=firefox title=\"x\"").is_empty());
     }
 
     #[test]
     fn ccectl_windows_optional_fields_default() {
         let out = parse_ccectl_windows("window id=3 app_id=firefox");
         assert_eq!(out.len(), 1);
         assert_eq!(out[0], ("3".into(), "firefox".into(), "".into(), false));
     }
 
     #[test]
     fn ccectl_windows_filters_own_surfaces() {
         let out = parse_ccectl_windows(
             "window id=1 app_id=cce-status\n\
              window id=2 app_id=cce-status-interface\n\
              window id=3 app_id=cce-cloud\n\
              window id=4 app_id=firefox",
         );
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].1, "firefox");
     }
 
     #[test]
     fn ccectl_windows_title_truncates_at_inner_quote() {
         // Known limitation of the legacy text format kept as the fallback for
         // pre---json compositors: titles are not escaped, so an inner quote
         // truncates the title. The JSON path below handles this correctly.
         let out = parse_ccectl_windows("window id=3 app_id=x title=\"say \"hi\"\" focused=false");
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].2, "say ");
     }
 
     // --- parse_ccectl_windows, JSON format (`windows --json`) ---
 
     #[test]
     fn ccectl_windows_json_full_line() {
         let out = parse_ccectl_windows(
             r#"{"id":3,"app_id":"firefox","title":"hello","mode":"grid","x":0,"y":0,"w":800,"h":600,"vx":0.0,"vy":0.0,"minimized":false,"has_parent":false,"focused":true,"ssd":false}"#,
         );
         assert_eq!(out.len(), 1);
         assert_eq!(out[0], ("3".to_string(), "firefox".to_string(), "hello".to_string(), true));
     }
 
     #[test]
     fn ccectl_windows_json_title_with_quotes_and_spaces() {
         // The reason --json exists: titles survive quoting untouched.
         let out = parse_ccectl_windows(
             r#"{"id":3,"app_id":"x","title":"say \"hi\" title=fake","focused":false}"#,
         );
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].2, "say \"hi\" title=fake");
     }
 
     #[test]
     fn ccectl_windows_json_filters_own_surfaces() {
         let out = parse_ccectl_windows(
             "{\"id\":1,\"app_id\":\"cce-status\",\"title\":\"\",\"focused\":false}\n\
              {\"id\":2,\"app_id\":\"cce-cloud\",\"title\":\"\",\"focused\":false}\n\
              {\"id\":3,\"app_id\":\"firefox\",\"title\":\"\",\"focused\":false}",
         );
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].1, "firefox");
     }
 
     #[test]
     fn ccectl_windows_json_missing_required_fields_skips_line() {
         assert!(parse_ccectl_windows(r#"{"app_id":"x","title":"no id"}"#).is_empty());
         assert!(parse_ccectl_windows(r#"{"id":3,"title":"no app_id"}"#).is_empty());
         assert!(parse_ccectl_windows("{not json").is_empty());
     }
 
     /// The fast path and the full stats push must agree about which modules
     /// are blind to a value; a disagreement would redraw a segment for a
     /// number it does not paint (and re-bake the compositor's blur with it).
     #[test]
     fn paints_stat_agrees_with_the_stats_signature() {
         let a = SystemStats {
             clock: "x".into(),
             memory: Some(1),
             cpu_pct: Some(1),
             battery: Some((1, false)),
             volume: Some((Some(10), false)),
             brightness: Some(10),
             wifi: Some((Some(80), true)),
         };
         for field in ["brightness", "volume"] {
             for module in [
                 None,
                 Some("stats"),
                 Some("brightness"),
                 Some("volume"),
                 Some("clock"),
                 Some("cpu"),
                 Some("memory"),
                 Some("battery"),
                 Some("wifi"),
                 Some("window"),
                 Some("tray"),
                 Some("light_source"),
             ] {
                 // Move only `field`, then ask both paths whether it shows.
                 let mut b = a.clone();
                 match field {
                     "brightness" => b.brightness = Some(50),
                     _ => b.volume = Some((Some(50), false)),
                 }
                 let by_signature = stats_signature(module, &a) != stats_signature(module, &b);
                 assert_eq!(
                     paints_stat(module, field),
                     by_signature,
                     "module {:?}, field {}",
                     module,
                     field
                 );
             }
         }
     }
 
     /// The sink and the default-sink change are ours; a single application's
     /// stream is not — `sink-input` fires throughout playback and would have
     /// us re-reading `pactl` the whole time.
     #[test]
     fn sink_events_exclude_sink_inputs() {
         assert!(is_sink_event("Event 'change' on sink #0"));
         assert!(is_sink_event("Event 'change' on server"));
         assert!(!is_sink_event("Event 'change' on sink-input #34"));
         assert!(!is_sink_event("Event 'new' on source-output #7"));
         assert!(!is_sink_event(""));
     }
 
     /// The signal is read off the interface's own row, the quality column's
     /// trailing dot and all, on cfg80211's 0..=70 scale; the two header rows
     /// and other interfaces' rows are not mistaken for it.
     #[test]
     fn wifi_signal_reads_the_interfaces_quality() {
         let table = "Inter-| sta-|   Quality        |   Discarded packets               | Missed | WE\n \
                       face | tus | link level noise |  nwid  crypt   frag  retry   misc | beacon | 22\n \
                      wlan1: 0000   35.  -75.  -256        0      0      0      0      0        0\n\
                      wlp0s20f3: 0000   63.  -47.  -256        0      0      0      0      2        0\n";
         assert_eq!(stats::wifi_signal(table, "wlp0s20f3"), Some(90));
         assert_eq!(stats::wifi_signal(table, "wlan1"), Some(50));
         assert_eq!(stats::wifi_signal(table, "wlan0"), None);
         assert_eq!(stats::wifi_signal("", "wlp0s20f3"), None);
     }
 }