@lattices/cli 0.4.5 → 0.4.7

package/app/Sources/Core/Desktop/SessionWindowLocator.swift

@@ -0,0 +1,139 @@
+import AppKit
+import ApplicationServices
+import CoreGraphics
+
+struct LocatedWindow {
+    let wid: UInt32
+    let pid: pid_t
+}
+
+enum SessionWindowLocator {
+    static func tag(for session: String) -> String {
+        Terminal.windowTag(for: session)
+    }
+
+    static func extractSessionName(from title: String) -> String? {
+        guard let range = title.range(of: #"\[lattices:([^\]]+)\]"#, options: .regularExpression) else {
+            return nil
+        }
+        let match = String(title[range])
+        return String(match.dropFirst(10).dropLast(1))
+    }
+
+    static func matches(session: String, title: String, extractedSessionName: String? = nil) -> Bool {
+        if extractedSessionName == session {
+            return true
+        }
+        return title.contains(tag(for: session))
+    }
+
+    static func cachedWindow(forSession session: String, in windows: [UInt32: WindowEntry]) -> WindowEntry? {
+        windows.values.first { entry in
+            matches(session: session, title: entry.title, extractedSessionName: entry.latticesSession)
+        }
+    }
+
+    static func cachedWindow(forSession session: String, desktopModel: DesktopModel = .shared) -> WindowEntry? {
+        cachedWindow(forSession: session, in: desktopModel.windows)
+    }
+
+    static func findCGWindow(tag: String) -> LocatedWindow? {
+        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
+            return nil
+        }
+
+        for info in windowList {
+            if let name = info[kCGWindowName as String] as? String,
+               name.contains(tag),
+               let wid = info[kCGWindowNumber as String] as? UInt32,
+               let pid = info[kCGWindowOwnerPID as String] as? pid_t {
+                return LocatedWindow(wid: wid, pid: pid)
+            }
+        }
+        return nil
+    }
+
+    static func findWindow(session: String, terminal: Terminal) -> LocatedWindow? {
+        findWindow(tag: tag(for: session), terminal: terminal)
+    }
+
+    static func findWindow(tag: String, terminal: Terminal) -> LocatedWindow? {
+        if let match = findCGWindow(tag: tag) {
+            return match
+        }
+
+        if let ax = findAXWindow(terminal: terminal, tag: tag),
+           let wid = matchCGWindow(pid: ax.pid, axWindow: ax.window) {
+            return LocatedWindow(wid: wid, pid: ax.pid)
+        }
+
+        return nil
+    }
+
+    static func findAXWindow(terminal: Terminal, tag: String) -> (pid: pid_t, window: AXUIElement)? {
+        let diag = DiagnosticLog.shared
+        guard let app = NSWorkspace.shared.runningApplications.first(where: {
+            $0.bundleIdentifier == terminal.bundleId
+        }) else {
+            diag.error("SessionWindowLocator.findAXWindow: \(terminal.rawValue) (\(terminal.bundleId)) not running")
+            return nil
+        }
+
+        let pid = app.processIdentifier
+        let appRef = AXUIElementCreateApplication(pid)
+        var windowsRef: CFTypeRef?
+        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
+        guard err == .success, let windows = windowsRef as? [AXUIElement] else {
+            diag.error("SessionWindowLocator.findAXWindow: AX error \(err.rawValue) — Accessibility not granted?")
+            return nil
+        }
+
+        diag.info("SessionWindowLocator.findAXWindow: \(windows.count) windows for \(terminal.rawValue), searching for \(tag)")
+        for win in windows {
+            var titleRef: CFTypeRef?
+            AXUIElementCopyAttributeValue(win, kAXTitleAttribute as CFString, &titleRef)
+            let title = titleRef as? String ?? "<no title>"
+            if title.contains(tag) {
+                diag.success("SessionWindowLocator.findAXWindow: matched \"\(title)\"")
+                return (pid, win)
+            } else {
+                diag.info("  skip: \"\(title)\"")
+            }
+        }
+
+        diag.warn("SessionWindowLocator.findAXWindow: no window matched tag \(tag)")
+        return nil
+    }
+
+    static func matchCGWindow(pid: pid_t, axWindow: AXUIElement) -> UInt32? {
+        var posRef: CFTypeRef?
+        var sizeRef: CFTypeRef?
+        AXUIElementCopyAttributeValue(axWindow, kAXPositionAttribute as CFString, &posRef)
+        AXUIElementCopyAttributeValue(axWindow, kAXSizeAttribute as CFString, &sizeRef)
+        guard let pv = posRef, let sv = sizeRef else { return nil }
+
+        var pos = CGPoint.zero
+        var size = CGSize.zero
+        AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
+        AXValueGetValue(sv as! AXValue, .cgSize, &size)
+
+        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
+            return nil
+        }
+
+        for info in windowList {
+            guard let wPid = info[kCGWindowOwnerPID as String] as? pid_t,
+                  wPid == pid,
+                  let wid = info[kCGWindowNumber as String] as? UInt32,
+                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary else { continue }
+            var rect = CGRect.zero
+            if CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) {
+                if abs(rect.origin.x - pos.x) < 2 && abs(rect.origin.y - pos.y) < 2 &&
+                    abs(rect.width - size.width) < 2 && abs(rect.height - size.height) < 2 {
+                    return wid
+                }
+            }
+        }
+        return nil
+    }
+}

package/app/Sources/Core/Desktop/WindowPreviewCard.swift

@@ -0,0 +1,100 @@
+import AppKit
+import SwiftUI
+
+struct WindowPreviewCardStyle {
+    var containerCornerRadius: CGFloat = 10
+    var imageCornerRadius: CGFloat = 8
+    var imagePadding: CGFloat = 8
+    var background: Color = Palette.surface.opacity(0.8)
+    var border: Color = Palette.border
+}
+
+struct WindowPreviewCard<Overlay: View>: View {
+    let image: NSImage?
+    let isLoading: Bool
+    let appName: String
+    var loadingTitle: String = "Capturing preview"
+    var unavailableTitle: String = "Preview unavailable"
+    var style: WindowPreviewCardStyle = WindowPreviewCardStyle()
+    var holdingPreviousPreview: Bool = false
+    @ViewBuilder let overlay: () -> Overlay
+
+    var body: some View {
+        ZStack {
+            RoundedRectangle(cornerRadius: style.containerCornerRadius)
+                .fill(style.background)
+                .overlay(
+                    RoundedRectangle(cornerRadius: style.containerCornerRadius)
+                        .strokeBorder(style.border, lineWidth: 0.5)
+                )
+
+            if let image {
+                Image(nsImage: image)
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .clipShape(RoundedRectangle(cornerRadius: style.imageCornerRadius))
+                    .padding(style.imagePadding)
+                    .opacity(holdingPreviousPreview ? 0.88 : 1)
+            } else if isLoading {
+                WindowPreviewPlaceholder(
+                    icon: "photo",
+                    title: loadingTitle,
+                    subtitle: appName
+                )
+            } else {
+                WindowPreviewPlaceholder(
+                    icon: "eye.slash",
+                    title: unavailableTitle,
+                    subtitle: appName
+                )
+            }
+
+            overlay()
+        }
+    }
+}
+
+extension WindowPreviewCard where Overlay == EmptyView {
+    init(
+        image: NSImage?,
+        isLoading: Bool,
+        appName: String,
+        loadingTitle: String = "Capturing preview",
+        unavailableTitle: String = "Preview unavailable",
+        style: WindowPreviewCardStyle = WindowPreviewCardStyle(),
+        holdingPreviousPreview: Bool = false
+    ) {
+        self.init(
+            image: image,
+            isLoading: isLoading,
+            appName: appName,
+            loadingTitle: loadingTitle,
+            unavailableTitle: unavailableTitle,
+            style: style,
+            holdingPreviousPreview: holdingPreviousPreview,
+            overlay: { EmptyView() }
+        )
+    }
+}
+
+private struct WindowPreviewPlaceholder: View {
+    let icon: String
+    let title: String
+    let subtitle: String
+
+    var body: some View {
+        VStack(spacing: 8) {
+            Image(systemName: icon)
+                .font(.system(size: 18, weight: .medium))
+                .foregroundColor(Palette.textMuted.opacity(0.7))
+            Text(title)
+                .font(Typo.monoBold(10))
+                .foregroundColor(Palette.textMuted)
+            Text(subtitle)
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textDim)
+                .lineLimit(1)
+        }
+        .padding(16)
+    }
+}

package/app/Sources/Core/Desktop/WindowPreviewStore.swift

@@ -0,0 +1,113 @@
+import AppKit
+import SwiftUI
+
+final class WindowPreviewStore: ObservableObject {
+    static let shared = WindowPreviewStore()
+
+    @Published private var images: [UInt32: NSImage] = [:]
+    @Published private var loading: Set<UInt32> = []
+
+    private var lastAttemptAt: [UInt32: Date] = [:]
+    private var accessOrder: [UInt32] = []
+    private let maxCached = 15
+    private let queue = DispatchQueue(label: "com.arach.lattices.window-preview", qos: .userInitiated)
+    private let previewMaxSize = NSSize(width: 360, height: 190)
+
+    func image(for wid: UInt32) -> NSImage? {
+        if images[wid] != nil {
+            touchLRU(wid)
+        }
+        return images[wid]
+    }
+
+    func hasSettled(_ wid: UInt32) -> Bool {
+        images[wid] != nil || (lastAttemptAt[wid] != nil && !loading.contains(wid))
+    }
+
+    func isLoading(_ wid: UInt32) -> Bool {
+        loading.contains(wid)
+    }
+
+    func prewarm(windows: [WindowEntry], limit: Int = 4) {
+        for window in windows.prefix(limit) {
+            load(window: window)
+        }
+    }
+
+    func load(window: WindowEntry) {
+        if images[window.wid] != nil || loading.contains(window.wid) {
+            return
+        }
+
+        let now = Date()
+        if let lastAttemptAt = lastAttemptAt[window.wid], now.timeIntervalSince(lastAttemptAt) < 1.0 {
+            return
+        }
+        lastAttemptAt[window.wid] = now
+
+        loading.insert(window.wid)
+        let wid = window.wid
+        let frame = window.frame
+        let startedAt = Date()
+
+        queue.async { [weak self] in
+            guard let self else { return }
+
+            let cgImage = CGWindowListCreateImage(
+                .null,
+                .optionIncludingWindow,
+                CGWindowID(wid),
+                [.boundsIgnoreFraming, .nominalResolution]
+            )
+
+            let image = cgImage.map {
+                NSImage(
+                    cgImage: $0,
+                    size: self.previewSize(for: frame)
+                )
+            }
+
+            DispatchQueue.main.async {
+                self.loading.remove(wid)
+                let elapsedMs = Int(Date().timeIntervalSince(startedAt) * 1000)
+                if let image {
+                    self.images[wid] = image
+                    self.touchLRU(wid)
+                    self.evictIfNeeded()
+                    if elapsedMs >= 80 {
+                        DiagnosticLog.shared.info("HUDPreview: captured wid=\(wid) in \(elapsedMs)ms")
+                    }
+                } else {
+                    DiagnosticLog.shared.info("HUDPreview: capture unavailable wid=\(wid) after \(elapsedMs)ms")
+                }
+            }
+        }
+    }
+
+    private func touchLRU(_ wid: UInt32) {
+        accessOrder.removeAll { $0 == wid }
+        accessOrder.append(wid)
+    }
+
+    private func evictIfNeeded() {
+        while images.count > maxCached, let oldest = accessOrder.first {
+            accessOrder.removeFirst()
+            images.removeValue(forKey: oldest)
+            lastAttemptAt.removeValue(forKey: oldest)
+        }
+    }
+
+    private func previewSize(for frame: WindowFrame) -> NSSize {
+        let width = max(CGFloat(frame.w), CGFloat(1))
+        let height = max(CGFloat(frame.h), CGFloat(1))
+        let scale = min(
+            previewMaxSize.width / width,
+            previewMaxSize.height / height,
+            CGFloat(1)
+        )
+        return NSSize(
+            width: max(CGFloat(1), width * scale),
+            height: max(CGFloat(1), height * scale)
+        )
+    }
+}

package/app/Sources/Core/Desktop/WindowSelectionStore.swift

@@ -0,0 +1,76 @@
+import Combine
+import Foundation
+
+struct SelectedWindowSummary: Identifiable, Equatable {
+    let wid: UInt32
+    let app: String
+    let title: String
+    let latticesSession: String?
+
+    var id: UInt32 { wid }
+
+    var displayTitle: String {
+        if !title.isEmpty { return title }
+        if let latticesSession, !latticesSession.isEmpty { return latticesSession }
+        return app
+    }
+}
+
+final class WindowSelectionStore: ObservableObject {
+    static let shared = WindowSelectionStore()
+
+    @Published private(set) var windows: [SelectedWindowSummary] = []
+    @Published private(set) var source: String?
+    @Published private(set) var updatedAt: Date?
+
+    private init() {}
+
+    var isActive: Bool { !windows.isEmpty }
+    var windowIds: [UInt32] { windows.map(\.wid) }
+    var count: Int { windows.count }
+    var sourceLabel: String? {
+        switch source {
+        case "desktop-inventory": return "window selector"
+        case "screen-map": return "screen map"
+        case let value?: return value
+        case nil: return nil
+        }
+    }
+
+    func setSelection(_ windows: [SelectedWindowSummary], source: String) {
+        let unique = Array(
+            Dictionary(uniqueKeysWithValues: windows.map { ($0.wid, $0) }).values
+        ).sorted { lhs, rhs in
+            if lhs.app == rhs.app { return lhs.wid < rhs.wid }
+            return lhs.app.localizedCaseInsensitiveCompare(rhs.app) == .orderedAscending
+        }
+
+        DispatchQueue.main.async {
+            self.windows = unique
+            self.source = source
+            self.updatedAt = Date()
+        }
+    }
+
+    func clear(source: String? = nil) {
+        DispatchQueue.main.async {
+            if let source, let current = self.source, current != source {
+                return
+            }
+            self.windows = []
+            self.source = source ?? self.source
+            self.updatedAt = Date()
+        }
+    }
+
+    func summary(maxItems: Int = 3) -> String {
+        guard !windows.isEmpty else { return "No selection" }
+        let titles = windows.prefix(maxItems).map { item in
+            item.app == item.displayTitle ? item.app : "\(item.app): \(item.displayTitle)"
+        }
+        if windows.count > maxItems {
+            return titles.joined(separator: " • ") + " +\(windows.count - maxItems)"
+        }
+        return titles.joined(separator: " • ")
+    }
+}

package/app/Sources/{WindowTiler.swift → Core/Desktop/WindowTiler.swift}

@@ -671,18 +671,7 @@ enum WindowTiler {
 
     /// Find a window by its title tag and return its CGWindowID and owner PID
     static func findWindow(tag: String) -> (wid: UInt32, pid: pid_t)? {
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return nil
-        }
-        for info in windowList {
-            if let name = info[kCGWindowName as String] as? String,
-               name.contains(tag),
-               let wid = info[kCGWindowNumber as String] as? UInt32,
-               let pid = info[kCGWindowOwnerPID as String] as? pid_t {
-                return (wid, pid)
-            }
-        }
-        return nil
+        SessionWindowLocator.findCGWindow(tag: tag).map { ($0.wid, $0.pid) }
     }
 
     /// Get the space ID(s) a window is on
@@ -760,13 +749,9 @@ enum WindowTiler {
 
         // Find the window — CG first, then AX→CG fallback
         let wid: UInt32
-        if let (w, _) = findWindow(tag: tag) {
-            wid = w
-            diag.info("moveWindowToSpace: found via CG wid=\(w)")
-        } else if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-                  let w = matchCGWindow(pid: pid, axWindow: axWindow) {
-            wid = w
-            diag.info("moveWindowToSpace: found via AX→CG wid=\(w)")
+        if let match = SessionWindowLocator.findWindow(tag: tag, terminal: terminal) {
+            wid = match.wid
+            diag.info("moveWindowToSpace: located wid=\(match.wid) pid=\(match.pid)")
         } else {
             diag.warn("moveWindowToSpace: window not found for tag \(tag) — switching view only")
             switchToSpace(spaceId: spaceId)
@@ -834,39 +819,31 @@ enum WindowTiler {
         let tag = Terminal.windowTag(for: session)
 
         // Path 1: CG window lookup (needs Screen Recording permission for window names)
-        if let (wid, pid) = findWindow(tag: tag) {
-            diag.success("Path 1 (CG): found wid=\(wid) pid=\(pid)")
-            navigateToKnownWindow(wid: wid, pid: pid, tag: tag, session: session, terminal: terminal)
+        if let match = SessionWindowLocator.findWindow(tag: tag, terminal: terminal) {
+            diag.success("Path 1/2 (locator): found wid=\(match.wid) pid=\(match.pid)")
+            navigateToKnownWindow(wid: match.wid, pid: match.pid, tag: tag, session: session, terminal: terminal)
             diag.finish(t)
             return
         }
-        diag.warn("Path 1 (CG): findWindow failed — no Screen Recording?")
+        diag.warn("SessionWindowLocator failed — trying direct AX fallback")
 
-        // Path 2: AX API fallback (needs Accessibility permission)
-        if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag) {
-            diag.success("Path 2 (AX): found window for \(terminal.rawValue) pid=\(pid)")
-            // Try to match AX window → CG window for space switching
-            if let wid = matchCGWindow(pid: pid, axWindow: axWindow) {
-                diag.success("Path 2 (AX→CG): matched CG wid=\(wid)")
-                navigateToKnownWindow(wid: wid, pid: pid, tag: tag, session: session, terminal: terminal)
+        if let (pid, axWindow) = SessionWindowLocator.findAXWindow(terminal: terminal, tag: tag) {
+            diag.success("Direct AX fallback: found window for \(terminal.rawValue) pid=\(pid)")
+            AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
+            AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
+            if let app = NSRunningApplication(processIdentifier: pid) {
+                app.activate()
+            }
+            if let frame = axWindowFrame(axWindow) {
+                diag.info("Highlighting via AX frame: \(frame)")
+                DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
             } else {
-                diag.warn("Path 2 (AX): no CG match — raising without space switch")
-                AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
-                if let app = NSRunningApplication(processIdentifier: pid) {
-                    app.activate()
-                }
-                if let frame = axWindowFrame(axWindow) {
-                    diag.info("Highlighting via AX frame: \(frame)")
-                    DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
-                } else {
-                    diag.error("axWindowFrame returned nil — no highlight")
-                }
+                diag.error("axWindowFrame returned nil — no highlight")
             }
             diag.finish(t)
             return
         }
-        diag.warn("Path 2 (AX): findWindowViaAX failed — no Accessibility?")
+        diag.warn("Direct AX fallback failed — no Accessibility?")
 
         // Path 3: AppleScript / bare activate fallback
         diag.warn("Path 3: falling back to AppleScript/activate")
@@ -894,70 +871,12 @@ enum WindowTiler {
         }
     }
 
-    /// Find a terminal window by title tag using AX API (requires Accessibility permission)
     private static func findWindowViaAX(terminal: Terminal, tag: String) -> (pid: pid_t, window: AXUIElement)? {
-        let diag = DiagnosticLog.shared
-        guard let app = NSWorkspace.shared.runningApplications.first(where: {
-            $0.bundleIdentifier == terminal.bundleId
-        }) else {
-            diag.error("findWindowViaAX: \(terminal.rawValue) (\(terminal.bundleId)) not running")
-            return nil
-        }
-
-        let pid = app.processIdentifier
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        guard err == .success, let windows = windowsRef as? [AXUIElement] else {
-            diag.error("findWindowViaAX: AX error \(err.rawValue) — Accessibility not granted?")
-            return nil
-        }
-
-        diag.info("findWindowViaAX: \(windows.count) windows for \(terminal.rawValue), searching for \(tag)")
-        for win in windows {
-            var titleRef: CFTypeRef?
-            AXUIElementCopyAttributeValue(win, kAXTitleAttribute as CFString, &titleRef)
-            let title = titleRef as? String ?? "<no title>"
-            if title.contains(tag) {
-                diag.success("findWindowViaAX: matched \"\(title)\"")
-                return (pid, win)
-            } else {
-                diag.info("  skip: \"\(title)\"")
-            }
-        }
-        diag.warn("findWindowViaAX: no window matched tag \(tag)")
-        return nil
+        SessionWindowLocator.findAXWindow(terminal: terminal, tag: tag)
     }
 
-    /// Match an AX window to its CG window ID using PID + bounds comparison
     private static func matchCGWindow(pid: pid_t, axWindow: AXUIElement) -> UInt32? {
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(axWindow, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(axWindow, kAXSizeAttribute as CFString, &sizeRef)
-        guard let pv = posRef, let sv = sizeRef else { return nil }
-
-        var pos = CGPoint.zero
-        var size = CGSize.zero
-        AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-        AXValueGetValue(sv as! AXValue, .cgSize, &size)
-
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else { return nil }
-
-        for info in windowList {
-            guard let wPid = info[kCGWindowOwnerPID as String] as? pid_t,
-                  wPid == pid,
-                  let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary else { continue }
-            var rect = CGRect.zero
-            if CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) {
-                if abs(rect.origin.x - pos.x) < 2 && abs(rect.origin.y - pos.y) < 2 &&
-                   abs(rect.width - size.width) < 2 && abs(rect.height - size.height) < 2 {
-                    return wid
-                }
-            }
-        }
-        return nil
+        SessionWindowLocator.matchCGWindow(pid: pid, axWindow: axWindow)
     }
 
     /// Get NSRect from an AX window element (AX uses top-left origin, convert to NS bottom-left)
@@ -1107,11 +1026,8 @@ enum WindowTiler {
 
         // Find the window
         let wid: UInt32
-        if let (w, _) = findWindow(tag: tag) {
-            wid = w
-        } else if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-                  let w = matchCGWindow(pid: pid, axWindow: axWindow) {
-            wid = w
+        if let match = SessionWindowLocator.findWindow(tag: tag, terminal: terminal) {
+            wid = match.wid
         } else {
             return nil
         }
@@ -2202,7 +2118,6 @@ enum WindowTiler {
         }
         return nil
     }
-
     private static func displaySpaces(containing cgPoint: CGPoint) -> DisplaySpaces? {
         guard let screenIndex = screenIndex(for: cgPoint) else { return nil }
         return getDisplaySpaces().first(where: { $0.displayIndex == screenIndex })
@@ -2218,7 +2133,6 @@ enum WindowTiler {
     private static func formatCGPoint(_ point: CGPoint) -> String {
         "\(Int(point.x)),\(Int(point.y))"
     }
-
     private static func screenIndex(for cgPoint: CGPoint) -> Int? {
         let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
         let nsPoint = NSPoint(x: cgPoint.x, y: primaryHeight - cgPoint.y)