feat: improvements and bug fixes

src-tauri/Cargo.toml

@@ -15,7 +15,7 @@ crate-type = ["staticlib", "cdylib", "rlib"]
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = ["tray-icon"] }
+tauri = { version = "2", features = ["tray-icon", "devtools"] }
 tauri-plugin-opener = "2"
 tauri-plugin-global-shortcut = "2"
 tauri-plugin-store = "2"

src-tauri/capabilities/default.json

@@ -2,7 +2,7 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "Capability for the main window",
-  "windows": ["main", "overlay", "whiteboard", "cursor-highlight", "spotlight", "zoom"],
+  "windows": ["main"],
   "permissions": [
     "core:default",
     "opener:default",

src-tauri/capabilities/mode-windows.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "mode-windows",
+  "description": "Minimal capability for overlay mode render windows (no global shortcuts, no autostart)",
+  "windows": ["overlay", "whiteboard", "cursor-highlight", "spotlight", "zoom"],
+  "permissions": [
+    "core:default",
+    "opener:default",
+    "store:default"
+  ]
+}

src-tauri/src/commands.rs

@@ -165,8 +165,8 @@ pub fn set_zoom_capture_excluded(excluded: bool) -> Result<(), String> {
 }
 
 #[tauri::command]
-pub fn freeze_zoom() -> Result<(), String> {
-    crate::zoom::stop_zoom_stream()?;
+pub async fn freeze_zoom() -> Result<(), String> {
+    crate::zoom::stop_zoom_stream().await?;
     #[cfg(target_os = "windows")]
     {
         crate::window::set_zoom_capture_exclusion(false);

src-tauri/src/cursor.rs

@@ -49,9 +49,9 @@ pub fn start_mouse_hook() {
         );
 
         let hook = SetWindowsHookExW(WH_MOUSE_LL, Some(mouse_hook_proc), None, 0);
-        let mut msg = std::mem::zeroed();
-        while GetMessageW(&mut msg, None, 0, 0).into() {}
         if let Ok(hook) = hook {
+            let mut msg = std::mem::zeroed();
+            while GetMessageW(&mut msg, None, 0, 0).into() {}
             if !hook.0.is_null() {
                 let _ = UnhookWindowsHookEx(hook);
             }

src-tauri/src/dxgi_capture.rs

@@ -9,6 +9,22 @@ use windows::Win32::Graphics::Dxgi::*;
 const DXGI_ERROR_WAIT_TIMEOUT: i32 = 0x887A0027u32 as i32;
 const DXGI_ERROR_ACCESS_LOST: i32 = 0x887A0026u32 as i32;
 
+/**
+ * RAII guard that unmaps a mapped D3D11 subresource on drop, including on panic/unwind.
+ */
+struct UnmapGuard<'a> {
+    context: &'a ID3D11DeviceContext,
+    resource: &'a ID3D11Texture2D,
+}
+
+impl Drop for UnmapGuard<'_> {
+    fn drop(&mut self) {
+        unsafe {
+            self.context.Unmap(self.resource, 0);
+        }
+    }
+}
+
 pub struct DxgiDuplicator {
     device: ID3D11Device,
     context: ID3D11DeviceContext,
@@ -270,6 +286,10 @@ impl DxgiDuplicator {
             self.context
                 .Map(staging, 0, D3D11_MAP_READ, 0, Some(&mut mapped))
                 .map_err(|e| format!("Map staging: {e}"))?;
+            let _unmap_guard = UnmapGuard {
+                context: &self.context,
+                resource: staging,
+            };
             let row_pitch = mapped.RowPitch as usize;
             let pixel_count = (region_w * region_h * 4) as usize;
             let mut rgba = Vec::with_capacity(pixel_count);
@@ -297,13 +317,9 @@ impl DxgiDuplicator {
                 }
             }
 
-            self.context.Unmap(staging, 0);
+            drop(_unmap_guard);
 
             Ok((rgba, region_w, region_h))
         }
     }
-
-    pub fn capture_full_frame(&mut self) -> Result<(Vec<u8>, u32, u32), String> {
-        self.capture_region(0, 0, self.width, self.height)
-    }
 }

src-tauri/src/lib.rs

@@ -15,30 +15,41 @@ struct ZoomConfig {
     backend: String,
 }
 
+/// In-memory zoom backend state. Seeded once from the compiled-in
+/// `config/zoom.json` factory default, then overwritten on every app start
+/// by `hydrate()` (frontend) via `set_zoom_backend_cmd`
 static ZOOM_BACKEND_STATE: OnceLock<RwLock<String>> = OnceLock::new();
 
+const DEFAULT_ZOOM_BACKEND: &str = "dxgi";
+
+fn init_zoom_backend_state() -> RwLock<String> {
+    let json_str = include_str!("../../config/zoom.json");
+    let backend = serde_json::from_str::<ZoomConfig>(json_str)
+        .map(|config| config.backend)
+        .unwrap_or_else(|e| {
+            eprintln!(
+                "Failed to parse zoom.json, falling back to default backend: {}",
+                e
+            );
+            DEFAULT_ZOOM_BACKEND.to_string()
+        });
+    RwLock::new(backend)
+}
+
 pub fn get_zoom_backend() -> String {
-    let state = ZOOM_BACKEND_STATE.get_or_init(|| {
-        let json_str = include_str!("../../config/zoom.json");
-        let config: ZoomConfig = serde_json::from_str(json_str).expect("Failed to parse zoom.json");
-        RwLock::new(config.backend)
-    });
+    let state = ZOOM_BACKEND_STATE.get_or_init(init_zoom_backend_state);
 
     match state.read() {
         Ok(guard) => guard.clone(),
         Err(e) => {
             eprintln!("Failed to read zoom backend state: {}", e);
-            "dxgi".to_string()
+            DEFAULT_ZOOM_BACKEND.to_string()
         }
     }
 }
 
 pub fn set_zoom_backend_internal(new_backend: String) {
-    let state = ZOOM_BACKEND_STATE.get_or_init(|| {
-        let json_str = include_str!("../../config/zoom.json");
-        let config: ZoomConfig = serde_json::from_str(json_str).expect("Failed to parse zoom.json");
-        RwLock::new(config.backend)
-    });
+    let state = ZOOM_BACKEND_STATE.get_or_init(init_zoom_backend_state);
 
     if let Ok(mut guard) = state.write() {
         *guard = new_backend;
@@ -73,6 +84,11 @@ pub fn run() {
         ))
         .plugin(tauri_plugin_opener::init())
         .setup(|app| {
+            #[cfg(debug_assertions)]
+            if let Some(window) = app.get_webview_window("main") {
+                window.open_devtools();
+            }
+
             #[cfg(target_os = "windows")]
             cursor::start_mouse_hook();
 
@@ -281,7 +297,6 @@ pub fn run() {
             zoom::stop_zoom_stream,
             commands::freeze_zoom,
             commands::unfreeze_zoom,
-            zoom::capture_viewport_without_zoom,
             commands::mag_zoom_show,
             commands::mag_zoom_hide,
             commands::mag_zoom_set_config,

src-tauri/src/magnifier.rs

@@ -309,7 +309,9 @@ unsafe fn apply_transform(mag: HWND, zoom: f32) {
 
 unsafe fn set_circle(hwnd: HWND, size: u32) {
     let rgn = CreateEllipticRgn(0, 0, size as i32, size as i32);
-    SetWindowRgn(hwnd, Some(rgn), true);
+    if SetWindowRgn(hwnd, Some(rgn), true) == 0 {
+        let _ = DeleteObject(rgn.into());
+    }
 }
 
 unsafe fn set_square(hwnd: HWND) {

src-tauri/src/types.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 use tauri::async_runtime::JoinHandle;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -46,15 +46,35 @@ pub struct MonitorContext {
 pub struct WindowRegistry {
     pub mode_windows: RwLock<HashMap<Mode, Vec<String>>>,
     pub current_snapshot: RwLock<String>,
+    mode_locks: HashMap<Mode, Mutex<()>>,
 }
 
 impl WindowRegistry {
     pub fn new() -> Self {
+        let mut mode_locks = HashMap::new();
+        for mode in [Mode::Overlay, Mode::Spotlight, Mode::Highlight, Mode::Zoom] {
+            mode_locks.insert(mode, Mutex::new(()));
+        }
+
         Self {
             mode_windows: RwLock::new(HashMap::new()),
             current_snapshot: RwLock::new(String::new()),
+            mode_locks,
         }
     }
+
+    /// Serializes the destroy→build→show sequence for a given [`Mode`] so
+    /// concurrent callers (monitor-change loop vs. visibility requests)
+    /// cannot interleave window mutations for the same mode.
+    pub fn with_mode_lock<T>(&self, mode: Mode, f: impl FnOnce() -> T) -> T {
+        let _guard = self
+            .mode_locks
+            .get(&mode)
+            .expect("mode_locks initialized for every Mode variant")
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+        f()
+    }
 }
 
 #[derive(serde::Serialize, Clone)]