feat: fetch_all_state parallel sidecar call + benchmark telemetry

- Add fetch_all_state Tauri command that runs get_monitors, get_dark_mode,
  and get_volume in parallel via tauri::async_runtime::spawn
- Frontend uses single fetch_all_state call instead of 3 separate invokes
- Add benchmark timing (START + duration) to all data-loading commands:
  get_monitors, get_dark_mode, get_volume, get_preferences,
  get_accessibility_trusted — only logged when debug_logging is on
- Fix get_preferences benchmark deadlock (drop lock before logging END)
- Call get_accessibility_trusted on popup open + visibility change

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: synle

src-tauri/src/config.rs

@@ -613,15 +613,21 @@ pub fn reset_to_defaults() {
 #[tauri::command]
 pub fn get_preferences(state: tauri::State<'_, crate::AppState>) -> Result<Preferences, String> {
     let t0 = std::time::Instant::now();
+    // Log START before acquiring the lock (write_debug_log uses try_lock internally,
+    // so it works here since we haven't locked yet).
+    write_debug_log(&state, "benchmark: get_preferences — START");
     let prefs = state.preferences.lock().map_err(|e| e.to_string())?;
     let result = prefs.clone();
+    let elapsed = t0.elapsed().as_secs_f64() * 1000.0;
+    let n_monitors = result.monitor_configs.len();
+    let n_profiles = result.profiles.len();
+    // Drop the lock BEFORE logging the END so write_debug_log can acquire it.
+    drop(prefs);
     write_debug_log(
         &state,
         &format!(
             "benchmark: get_preferences — {:.1}ms (in-memory, {} monitors, {} profiles)",
-            t0.elapsed().as_secs_f64() * 1000.0,
-            result.monitor_configs.len(),
-            result.profiles.len(),
+            elapsed, n_monitors, n_profiles,
         ),
     );
     Ok(result)

src-tauri/src/dark_mode.rs

@@ -19,6 +19,7 @@ pub async fn get_dark_mode(
     state: tauri::State<'_, crate::AppState>,
 ) -> Result<bool, String> {
     let t0 = std::time::Instant::now();
+    crate::config::write_debug_log(&state, "benchmark: get_dark_mode — START");
 
     if let Some(cached) = state.sidecar_cache.get_dark_mode() {
         crate::config::write_debug_log(

src-tauri/src/display.rs

@@ -203,6 +203,7 @@ pub async fn get_monitors(
     state: tauri::State<'_, crate::AppState>,
 ) -> Result<Vec<Monitor>, String> {
     let t0 = std::time::Instant::now();
+    crate::config::write_debug_log(&state, "benchmark: get_monitors — START");
 
     // Return cached monitors if fresh
     if let Some(cached) = state.sidecar_cache.get_monitors() {
@@ -213,8 +214,13 @@ pub async fn get_monitors(
         return Ok(cached);
     }
 
+    crate::config::write_debug_log(&state, "benchmark: get_monitors — calling sidecar...");
     let monitors = detect_monitors().await;
     let t_sidecar = t0.elapsed();
+    crate::config::write_debug_log(
+        &state,
+        &format!("benchmark: get_monitors — sidecar returned in {:.1}ms ({} displays)", t_sidecar.as_secs_f64() * 1000.0, monitors.len()),
+    );
 
     let mut prefs = state.preferences.lock().map_err(|e| e.to_string())?;
 

src-tauri/src/lib.rs

@@ -44,6 +44,73 @@ pub fn server_port() -> u16 {
     SERVER_PORT.load(Ordering::Relaxed)
 }
 
+/// Response from `fetch_all_state` — all sidecar data in one call.
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AllState {
+    pub monitors: Vec<display::Monitor>,
+    pub is_dark: bool,
+    pub volume: u32,
+}
+
+/// Fetches monitors, dark mode, and volume from the sidecar in parallel.
+/// Returns all three in a single response so the frontend only makes one
+/// IPC call. Logs benchmark timing for each sub-call and the total.
+#[tauri::command]
+async fn fetch_all_state(
+    app: tauri::AppHandle,
+) -> Result<AllState, String> {
+    use tauri::Manager;
+    let t0 = std::time::Instant::now();
+    if let Some(s) = app.try_state::<AppState>() {
+        config::write_debug_log(&s, "benchmark: fetch_all_state — START");
+    }
+
+    // Run all 3 sidecar calls in parallel using spawned tasks.
+    // Each task gets its own AppHandle clone (cheap Arc clone).
+    let a1 = app.clone();
+    let a2 = app.clone();
+    let a3 = app.clone();
+
+    let h_monitors = tauri::async_runtime::spawn(async move {
+        let state = a1.state::<AppState>();
+        display::get_monitors(state).await
+    });
+    let h_dark = tauri::async_runtime::spawn(async move {
+        let state = a2.state::<AppState>();
+        dark_mode::get_dark_mode(state).await
+    });
+    let h_volume = tauri::async_runtime::spawn(async move {
+        let state = a3.state::<AppState>();
+        volume::get_volume(state).await
+    });
+
+    let monitors_result = h_monitors.await.map_err(|e| e.to_string())?;
+    let dark_result = h_dark.await.map_err(|e| e.to_string())?;
+    let volume_result = h_volume.await.map_err(|e| e.to_string())?;
+
+    let monitors = monitors_result.unwrap_or_default();
+    let is_dark = dark_result.unwrap_or(false);
+    let volume = volume_result.unwrap_or(0);
+
+    let elapsed = t0.elapsed().as_secs_f64() * 1000.0;
+    if let Some(s) = app.try_state::<AppState>() {
+        config::write_debug_log(
+            &s,
+            &format!(
+                "benchmark: fetch_all_state — {:.1}ms total ({} monitors, is_dark={}, volume={})",
+                elapsed, monitors.len(), is_dark, volume,
+            ),
+        );
+    }
+
+    Ok(AllState {
+        monitors,
+        is_dark,
+        volume,
+    })
+}
+
 pub struct AppState {
     pub preferences: std::sync::Mutex<config::Preferences>,
     pub last_tray_rect: std::sync::Mutex<Option<tauri::Rect>>,
@@ -380,6 +447,7 @@ pub fn run() {
             sidecar_cache: sidecar_cache::SidecarCache::new(),
         })
         .invoke_handler(tauri::generate_handler![
+            fetch_all_state,
             display::get_monitors,
             display::set_brightness,
             display::set_all_brightness,

src-tauri/src/tiling/mod.rs

@@ -1011,6 +1011,7 @@ pub fn get_accessibility_trusted(
     state: tauri::State<'_, crate::AppState>,
 ) -> bool {
     let t0 = std::time::Instant::now();
+    crate::config::write_debug_log(&state, "benchmark: get_accessibility_trusted — START");
 
     if let Some(cached) = state.sidecar_cache.get_accessibility() {
         crate::config::write_debug_log(

src-tauri/src/volume.rs

@@ -19,6 +19,7 @@ pub async fn get_volume(
     state: tauri::State<'_, crate::AppState>,
 ) -> Result<u32, String> {
     let t0 = std::time::Instant::now();
+    crate::config::write_debug_log(&state, "benchmark: get_volume — START");
 
     if let Some(cached) = state.sidecar_cache.get_volume() {
         crate::config::write_debug_log(

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/nicoverbruggen/tauri-v2-docs/refs/heads/main/schemas/config.schema.json",
   "productName": "Display DJ",
-  "version": "6.3.17",
+  "version": "6.3.18",
   "identifier": "com.synle.display-dj",
   "build": {
     "beforeDevCommand": "npm run dev",

src/App.tsx

@@ -83,12 +83,27 @@ function App() {
     }
   }, []);
 
+  /** Fetches monitors, dark mode, and volume in a single parallel sidecar call. */
+  const fetchAllState = useCallback(async () => {
+    try {
+      const state = await invoke<{
+        monitors: Monitor[];
+        isDark: boolean;
+        volume: number;
+      }>('fetch_all_state');
+      setMonitors(state.monitors);
+      setDarkMode(state.isDark);
+      setVolume(state.volume);
+    } catch (e) {
+      console.error('Failed to fetch all state:', e);
+    }
+  }, []);
+
   useEffect(() => {
-    fetchMonitors();
-    fetchDarkMode();
-    fetchVolume();
+    fetchAllState();
     fetchPreferences();
     fetchKeepAwake();
+    invoke<boolean>('get_accessibility_trusted').catch(() => {});
     invoke<string>('get_app_version')
       .then(setVersion)
       .catch(() => {});
@@ -105,10 +120,9 @@ function App() {
     // Also refetch when window becomes visible
     const handleVisibility = () => {
       if (document.visibilityState === 'visible') {
-        fetchMonitors();
-        fetchDarkMode();
-        fetchVolume();
+        fetchAllState();
         fetchKeepAwake();
+        invoke<boolean>('get_accessibility_trusted').catch(() => {});
       }
     };
     document.addEventListener('visibilitychange', handleVisibility);