Fix coordinate conversion and resource leaks from code review

Coordinate conversion (SimpleViewModel.swift):
- Fixed multi-monitor coordinate conversion to use global maxY
- Previous per-screen logic was incorrect and caused wrong Y positions
- Now properly accounts for entire virtual screen space

Resource management (SimpleHotkeyManager.swift):
- Restored stopMonitoring() to MainActor with proper cleanup
- Fixed stopMouseMonitoring() to dispatch cleanup to MainActor
- Both methods now properly nil out monitor properties and callbacks
- Prevents memory leaks from retained closures in singleton
- Removed nonisolated(unsafe) annotations (no longer needed)

These fixes address all issues identified in code review.

Author: claude

Sources/ClickIt/Lite/SimpleHotkeyManager.swift

@@ -15,12 +15,12 @@ final class SimpleHotkeyManager {
 
     // MARK: - Properties
 
-    nonisolated(unsafe) private var globalMonitor: Any?
-    nonisolated(unsafe) private var localMonitor: Any?
+    private var globalMonitor: Any?
+    private var localMonitor: Any?
     private var onEmergencyStop: (() -> Void)?
 
-    nonisolated(unsafe) private var globalMouseMonitor: Any?
-    nonisolated(unsafe) private var localMouseMonitor: Any?
+    private var globalMouseMonitor: Any?
+    private var localMouseMonitor: Any?
     private var onRightMouseClick: (() -> Void)?
     private var lastClickTime: TimeInterval = 0
     private let clickDebounceInterval: TimeInterval = 0.1
@@ -60,13 +60,16 @@ final class SimpleHotkeyManager {
     }
 
     /// Stop monitoring
-    nonisolated func stopMonitoring() {
+    func stopMonitoring() {
         if let monitor = globalMonitor {
             NSEvent.removeMonitor(monitor)
+            globalMonitor = nil
         }
         if let monitor = localMonitor {
             NSEvent.removeMonitor(monitor)
+            localMonitor = nil
         }
+        onEmergencyStop = nil
     }
 
     /// Start monitoring for right mouse clicks (Live Mouse Mode)
@@ -91,11 +94,17 @@ final class SimpleHotkeyManager {
 
     /// Stop mouse monitoring
     nonisolated func stopMouseMonitoring() {
-        if let monitor = globalMouseMonitor {
-            NSEvent.removeMonitor(monitor)
-        }
-        if let monitor = localMouseMonitor {
-            NSEvent.removeMonitor(monitor)
+        // Dispatch cleanup to the main actor to safely access and nil out properties.
+        Task { @MainActor in
+            if let monitor = self.globalMouseMonitor {
+                NSEvent.removeMonitor(monitor)
+                self.globalMouseMonitor = nil
+            }
+            if let monitor = self.localMouseMonitor {
+                NSEvent.removeMonitor(monitor)
+                self.localMouseMonitor = nil
+            }
+            self.onRightMouseClick = nil
         }
     }
 

Sources/ClickIt/Lite/SimpleViewModel.swift

@@ -127,28 +127,22 @@ final class SimpleViewModel: ObservableObject {
 
 private extension NSPoint {
     func asCGPoint() -> CGPoint {
-        // Convert from AppKit coordinates (bottom-left origin) to CG coordinates (top-left origin)
-        // Find the screen containing this point
-        let screens = NSScreen.screens
-
-        // Find which screen contains this point
-        for screen in screens {
-            let frame = screen.frame
-            if frame.contains(self) {
-                // Convert using this screen's frame
-                let screenY = frame.origin.y
-                let screenHeight = frame.height
-                return CGPoint(x: x, y: screenY + screenHeight - y)
-            }
+        // Convert from AppKit coordinates (bottom-left origin) to CG coordinates (top-left origin).
+        // This must account for the entire virtual screen space in multi-monitor setups.
+
+        // The total height of the virtual screen space is the max Y coordinate across all screens.
+        // The conversion is then to subtract the AppKit Y from this total height.
+        if let globalMaxY = NSScreen.screens.map({ $0.frame.maxY }).max() {
+            return CGPoint(x: x, y: globalMaxY - y)
         }
 
-        // Fallback: use the screen with the highest Y (topmost screen)
-        // This handles the full desktop coordinate space
-        if let maxY = screens.map({ $0.frame.maxY }).max() {
-            return CGPoint(x: x, y: maxY - y)
+        // As a fallback, use the main screen's height, which works for single-monitor setups.
+        if let mainScreen = NSScreen.main {
+            let screenHeight = mainScreen.frame.height
+            return CGPoint(x: x, y: screenHeight - y)
         }
 
-        // Ultimate fallback
+        // Ultimate fallback if no screen information is available.
         return CGPoint(x: x, y: y)
     }
 }