Reject window captures that composite extra windows

ScreenCaptureKit's desktopIndependentWindow filter can include owned
child windows (e.g. an app dialog plus its parent), producing a capture
much larger than the picked window. Detect the overflow by comparing the
returned image size against the window's frame and fall back to the
screen crop with rounded mask. Hover changes are logged with the picked
window id and tracked count for diagnosis.

💘 Generated with Crush

Assisted-by: Crush:deepseek-v4-flash-0731

Sources/Kapture/App.swift

@@ -21,6 +21,17 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
             runOCRSelfTest()
             return
         }
+        // Single instance: stale copies keep their own hotkey + overlays alive
+        // after app updates and eat clicks meant for the new instance.
+        let myPid = ProcessInfo.processInfo.processIdentifier
+        let others = NSRunningApplication.runningApplications(withBundleIdentifier: "dev.tzgyn.kapture")
+            .filter { $0.processIdentifier != myPid }
+        if !others.isEmpty {
+            CaptureController.log("launch: other Kapture instances pids=\(others.map { String($0.processIdentifier) }.joined(separator: ",")) — terminating them")
+            for other in others {
+                other.forceTerminate()
+            }
+        }
         HotkeyManager.shared.onTrigger = { CaptureController.shared.begin() }
         HotkeyManager.shared.register()
     }
@@ -79,6 +90,13 @@ enum PermissionManager {
     static func request() {
         CGRequestScreenCaptureAccess()
     }
+
+    static var isAccessibilityGranted: Bool { AXIsProcessTrusted() }
+
+    static func requestAccessibility() {
+        let opts = [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        _ = AXIsProcessTrustedWithOptions(opts)
+    }
 }
 
 enum LoginItem {

Sources/Kapture/CaptureController.swift

@@ -1,27 +1,48 @@
 import AppKit
 import CoreGraphics
 import ScreenCaptureKit
+import ApplicationServices
 
 final class CaptureController: NSObject {
     static let shared = CaptureController()
 
-    private var overlays: [NSWindow] = []
+    private var overlays: [OverlayWindow] = []
     private(set) var isSelecting = false
     private var previousApp: NSRunningApplication?
     private var overlayIDs: [Int] = []
 
+    // Selection state (driven by the event tap; AppKit global coordinates)
+    private var marqueeStart: NSPoint?
+    private(set) var marqueeRect: NSRect?
+    private(set) var hoverWindow: (id: CGWindowID, frame: NSRect)?
+    var hoverFrame: NSRect? { hoverWindow?.frame }
+    private var trackedWindows: [(id: CGWindowID, frame: NSRect)] = []
+    private var lastWindowScan = Date.distantPast
+    private var eventTap: CFMachPort?
+
     /// Session event log for debugging (dumped via Copy Diagnostics).
+    /// Also appended to /tmp/kapture-debug.log so it survives relaunches.
     static var sessionLog: [String] = []
     static func log(_ line: String) {
-        sessionLog.append(line)
+        let stamped = String(format: "%@ %@", DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .medium), line)
-        if sessionLog.count > 100 { sessionLog.removeFirst() }
+        sessionLog.append(stamped)
+        if sessionLog.count > 200 { sessionLog.removeFirst() }
         NSLog("[Kapture] \(line)")
+        let path = "/tmp/kapture-debug.log"
+        if let handle = FileHandle(forWritingAtPath: path) {
+            handle.seekToEndOfFile()
+            handle.write((stamped + "\n").data(using: .utf8)!)
+            handle.closeFile()
+        } else {
+            FileManager.default.createFile(atPath: path, contents: (stamped + "\n").data(using: .utf8))
+        }
     }
 
     /// Diagnostic snapshot for "Copy Diagnostics" menu item.
     func diagnostics() -> String {
         var lines: [String] = []
         lines.append("Kapture diagnostics — version \(Bundle.main.infoDictionary?["CFBundleShortVersionString"] ?? "?")")
+        lines.append("accessibility=\(AXIsProcessTrusted()) eventTap=\(eventTap != nil)")
         lines.append("--- session log (newest last) ---")
         lines.append(contentsOf: Self.sessionLog)
         lines.append("--- screens ---")
@@ -53,6 +74,8 @@ final class CaptureController: NSObject {
         return lines.joined(separator: "\n")
     }
 
+    // MARK: - Session lifecycle
+
     func begin() {
         guard !isSelecting else { return }
         guard PermissionManager.isGranted else {
@@ -61,32 +84,34 @@ final class CaptureController: NSObject {
         }
         isSelecting = true
         previousApp = NSWorkspace.shared.frontmostApplication
-        // Force activation: cooperative NSApp.activate() can silently fail for
+        // Activation is async on macOS 26; wait a tick so the app is active
-        // LSUIElement apps, leaving the app inactive — then clicks on the
+        // before the overlays appear (otherwise clicks pass through).
-        // overlays pass through to the windows below.
         NSApp.activate(ignoringOtherApps: true)
-        CaptureController.log("begin: creating overlays for \(NSScreen.screens.count) screens")
+        CaptureController.log("begin: activate issued, active=\(NSApp.isActive)")
-        overlays = NSScreen.screens.map { screen in
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
-            OverlayWindow(
+            guard let self, self.isSelecting else { return }
-                screen: screen,
+            CaptureController.log("begin: active=\(NSApp.isActive) — showing overlays")
-                onComplete: { [weak self] rect in self?.finishSelection(rect) },
+            self.overlays = NSScreen.screens.map { screen in
-                onCancel: { [weak self] in self?.cancelSelection() },
+                let panel = OverlayWindow(screen: screen, controller: self)
-                onWindowPick: { [weak self] rect in self?.finishWindowPick(rect) }
+                (panel.contentView as? OverlayView)?.controller = self
-            )
+                return panel
+            }
+            self.overlays.forEach { $0.makeKeyAndOrderFront(nil) }
+            self.overlayIDs = self.overlays.map { $0.windowNumber }
+            CaptureController.log("begin: \(self.overlays.count) overlays, ids=\(self.overlayIDs), active=\(NSApp.isActive)")
+            self.installEventTap()
         }
-        overlays.forEach { $0.makeKeyAndOrderFront(nil) }
-        overlayIDs = overlays.map { $0.windowNumber }
-        CaptureController.log("begin: \(overlays.count) overlays, ids=\(overlayIDs), active=\(NSApp.isActive)")
     }
 
-    /// A window was picked from hover — capture it with rounded corners.
+    /// A window was picked from hover — capture it directly (real rounded
-    private func finishWindowPick(_ rect: NSRect) {
+    /// corners come from the window's own alpha).
+    private func finishWindowPick(_ windowID: CGWindowID, _ rect: NSRect) {
         let ids = overlayIDs
         hideOverlays()
         isSelecting = false
         restorePreviousApp()
         DispatchQueue.main.async { [self] in
-            capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+            capture(rect, excludingWindowIDs: ids, windowID: windowID)
         }
     }
 
@@ -109,8 +134,12 @@ final class CaptureController: NSObject {
     }
 
     private func hideOverlays() {
+        removeEventTap()
         overlays.forEach { $0.orderOut(nil) }
         overlays = []
+        marqueeRect = nil
+        hoverWindow = nil
+        marqueeStart = nil
     }
 
     private func restorePreviousApp() {
@@ -118,8 +147,196 @@ final class CaptureController: NSObject {
         previousApp = nil
     }
 
-    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int], roundedCorners: Bool = false) {
+    private func renderOverlays() {
-        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids, roundedCorners: roundedCorners) { [weak self] image in
+        for overlay in overlays {
+            (overlay.contentView as? OverlayView)?.needsDisplay = true
+        }
+    }
+
+    // MARK: - Event tap
+
+    private func installEventTap() {
+        guard eventTap == nil else { return }
+        guard AXIsProcessTrusted() else {
+            CaptureController.log("tap: accessibility not granted — falling back to panel events")
+            PermissionManager.requestAccessibility()
+            return
+        }
+        let mask: CGEventMask = (1 << CGEventType.mouseMoved.rawValue)
+            | (1 << CGEventType.leftMouseDown.rawValue)
+            | (1 << CGEventType.leftMouseDragged.rawValue)
+            | (1 << CGEventType.leftMouseUp.rawValue)
+            | (1 << CGEventType.keyDown.rawValue)
+        guard let tap = CGEvent.tapCreate(
+            tap: .cghidEventTap,
+            place: .headInsertEventTap,
+            options: .defaultTap,
+            eventsOfInterest: CGEventMask(mask),
+            callback: Self.tapCallback,
+            userInfo: Unmanaged.passUnretained(self).toOpaque()
+        ) else {
+            CaptureController.log("tap: creation FAILED — falling back to panel events")
+            return
+        }
+        eventTap = tap
+        if let source = CFMachPortCreateRunLoopSource(nil, tap, 0) {
+            CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
+        }
+        CGEvent.tapEnable(tap: tap, enable: true)
+        CaptureController.log("tap: installed")
+    }
+
+    private func removeEventTap() {
+        guard let tap = eventTap else { return }
+        CGEvent.tapEnable(tap: tap, enable: false)
+        if let source = CFMachPortCreateRunLoopSource(nil, tap, 0) {
+            CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes)
+        }
+        CFMachPortInvalidate(tap)
+        eventTap = nil
+        CaptureController.log("tap: removed")
+    }
+
+    private static let tapCallback: CGEventTapCallBack = { _, type, event, refcon in
+        guard let refcon else { return Unmanaged.passUnretained(event) }
+        let controller = Unmanaged<CaptureController>.fromOpaque(refcon).takeUnretainedValue()
+        if let result = controller.handleTap(type, event) {
+            return Unmanaged.passUnretained(result)
+        }
+        return nil
+    }
+
+    /// Convert a CG global point (top-left origin) to AppKit global.
+    private func cgPointToAppKit(_ p: NSPoint) -> NSPoint {
+        guard let mainScreen = NSScreen.screens.first else { return p }
+        return NSPoint(x: p.x, y: mainScreen.frame.height - p.y)
+    }
+
+    /// Scan on-screen windows (AppKit global frames), front to back.
+    private func refreshTrackedWindows() {
+        guard let list = CGWindowListCopyWindowInfo(
+            [ .optionOnScreenOnly, .excludeDesktopElements ], kCGNullWindowID
+        ) as? [[String: Any]] else { trackedWindows = []; return }
+
+        let ownIDs = Set(overlayIDs)
+        var found: [(id: CGWindowID, frame: NSRect)] = []
+        for info in list {
+            guard let cid = info[kCGWindowNumber as String] as? CGWindowID,
+                  let bounds = info[kCGWindowBounds as String] as? [String: CGFloat],
+                  let layer = info[kCGWindowLayer as String] as? Int,
+                  layer == 0
+            else { continue }
+            if ownIDs.contains(Int(cid)) { continue }
+            let cgRect = NSRect(
+                x: bounds["X"] ?? 0,
+                y: bounds["Y"] ?? 0,
+                width: bounds["Width"] ?? 0,
+                height: bounds["Height"] ?? 0
+            )
+            guard cgRect.width >= 80, cgRect.height >= 60 else { continue }
+            let rect = Self.cgToAppKit(rect: cgRect)
+            found.append((cid, rect))
+        }
+        trackedWindows = found
+    }
+
+    /// Convert a CGWindowList (top-left origin) frame into AppKit screen
+    /// coordinates (bottom-left origin).
+    private static func cgToAppKit(rect: NSRect) -> NSRect {
+        guard let mainScreen = NSScreen.screens.first else { return rect }
+        let y = mainScreen.frame.height - rect.origin.y - rect.height
+        return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
+    }
+
+    private func topmostWindowContaining(_ appKitPoint: NSPoint) -> (id: CGWindowID, frame: NSRect)? {
+        for entry in trackedWindows {
+            if entry.frame.contains(appKitPoint) {
+                return entry
+            }
+        }
+        return nil
+    }
+
+    /// Returns the event to pass through, or nil to consume it.
+    func handleTap(_ type: CGEventType, _ event: CGEvent) -> CGEvent? {
+        guard isSelecting else { return event }
+
+        switch type {
+        case .tapDisabledByUserInput, .tapDisabledByTimeout:
+            // A timed-out tap must be re-enabled; guard against a torn-down tap.
+            if let tap = eventTap {
+                CGEvent.tapEnable(tap: tap, enable: true)
+                CaptureController.log("tap: re-enabled after \(type)")
+            }
+            return event
+        case .keyDown:
+            if event.getIntegerValueField(.keyboardEventKeycode) == 53 {
+                CaptureController.log("tap: Esc — cancel")
+                cancelSelection()
+                return nil
+            }
+            return event
+        case .mouseMoved, .leftMouseDragged:
+            // Throttle window scans while moving
+            if Date().timeIntervalSince(lastWindowScan) > 0.15 {
+                lastWindowScan = Date()
+                refreshTrackedWindows()
+            }
+            let appKitPoint = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
+            if type == .mouseMoved {
+                let window = topmostWindowContaining(appKitPoint)
+                if window?.frame != hoverFrame {
+                    hoverWindow = window
+                    if let w = window {
+                        CaptureController.log("hover: picked id=\(w.id) frame=\(w.frame) (tracked=\(trackedWindows.count))")
+                    } else {
+                        CaptureController.log("hover: none (tracked=\(trackedWindows.count))")
+                    }
+                    renderOverlays()
+                }
+                return event
+            }
+            // Drag: grow the marquee
+            guard let start = marqueeStart else { return nil }
+            let rect = NSRect(
+                x: min(start.x, appKitPoint.x),
+                y: min(start.y, appKitPoint.y),
+                width: abs(appKitPoint.x - start.x),
+                height: abs(appKitPoint.y - start.y)
+            )
+            marqueeRect = rect
+            hoverWindow = nil
+            renderOverlays()
+            return nil
+        case .leftMouseDown:
+            marqueeStart = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
+            marqueeRect = nil
+            CaptureController.log("tap: mouseDown at \(marqueeStart.map { "\($0)" } ?? "?")")
+            return nil
+        case .leftMouseUp:
+            defer { marqueeStart = nil; marqueeRect = nil }
+            let appKitPoint = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
+            let dragDistance = marqueeStart.map { hypot($0.x - appKitPoint.x, $0.y - appKitPoint.y) } ?? 0
+            if let rect = marqueeRect, dragDistance >= 4, rect.width >= 2, rect.height >= 2 {
+                CaptureController.log("tap: marquee complete \(rect)")
+                finishSelection(rect)
+            } else if let hover = hoverWindow {
+                CaptureController.log("tap: window pick id=\(hover.id) \(hover.frame)")
+                finishWindowPick(hover.id, hover.frame)
+            } else {
+                CaptureController.log("tap: click with no hover/marquee — cancel")
+                cancelSelection()
+            }
+            return nil
+        default:
+            return event
+        }
+    }
+
+    // MARK: - Capture
+
+    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int], roundedCorners: Bool = false, windowID: CGWindowID? = nil) {
+        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids, roundedCorners: roundedCorners, windowID: windowID) { [weak self] image in
             DispatchQueue.main.async {
                 self?.isSelecting = false
                 self?.restorePreviousApp()
@@ -128,6 +345,7 @@ final class CaptureController: NSObject {
                         ResultWindow.shared.show(image: ResultWindow.failureImage("Capture failed. Check Screen Recording permission."))
                         return
                     }
+                    CaptureController.log("capture done: \(image.width)x\(image.height) — showing result window")
                     ResultWindow.shared.show(image: image)
                 }
             }
@@ -203,7 +421,7 @@ final class ScreenCapture {
         return content.displays.first(where: { $0.displayID == cgID }) ?? content.displays.first
     }
 
-    func capture(_ rect: NSRect, excludingWindowIDs excludedIDs: [Int], roundedCorners: Bool = false, completion: @escaping (CGImage?) -> Void) {
+    func capture(_ rect: NSRect, excludingWindowIDs excludedIDs: [Int], roundedCorners: Bool = false, windowID: CGWindowID? = nil, completion: @escaping (CGImage?) -> Void) {
         if #available(macOS 14.0, *) {
             Task {
                 guard let content = try? await SCShareableContent.current,
@@ -226,7 +444,7 @@ final class ScreenCapture {
                 let backingScale = screen.backingScaleFactor
                 config.width = Int(CGFloat(display.width) * backingScale)
                 config.height = Int(CGFloat(display.height) * backingScale)
-                config.showsCursor = true
+                config.showsCursor = false
 
                 // ScreenCaptureKit uses a different origin than AppKit for
                 // screens stacked around the main display: per-display,
@@ -238,10 +456,42 @@ final class ScreenCapture {
                     height: rect.height
                 )
 
+                // Window pick: capture the window DIRECTLY — the image comes
+                // with the app's real rounded-corner alpha (no mask guessing).
+                if let windowID,
+                   let scWindow = content.windows.first(where: { $0.windowID == windowID }) {
+                    var windowConfig = SCStreamConfiguration()
+                    windowConfig.width = Int(scWindow.frame.width * backingScale)
+                    windowConfig.height = Int(scWindow.frame.height * backingScale)
+                            windowConfig.showsCursor = false
+                    if let windowImage = try? await SCScreenshotManager.captureImage(
+                        contentFilter: SCContentFilter(desktopIndependentWindow: scWindow),
+                        configuration: windowConfig
+                    ) {
+                        let expectedW = CGFloat(scWindow.frame.width) * backingScale
+                        let expectedH = CGFloat(scWindow.frame.height) * backingScale
+                        let overflow = max(
+                            CGFloat(windowImage.width) / max(expectedW, 1),
+                            CGFloat(windowImage.height) / max(expectedH, 1)
+                        )
+                        if overflow > 1.35 {
+                            // SCKit composited extra windows (owned popups etc.)
+                            // — reject and use the screen crop instead.
+                            CaptureController.log("capture: WINDOW id=\(windowID) overflow=\(overflow) (\(windowImage.width)x\(windowImage.height) vs \(Int(expectedW))x\(Int(expectedH))) — rejecting, using crop+mask")
+                        } else {
+                            CaptureController.log("capture: WINDOW id=\(windowID) image=\(windowImage.width)x\(windowImage.height) (native alpha corners)")
+                            completion(windowImage)
+                            return
+                        }
+                    }
+                    CaptureController.log("capture: window filter failed for id=\(windowID) — falling back to crop+mask")
+                }
+
                 guard let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config) else {
                     completion(nil)
                     return
                 }
+                CaptureController.log("capture: rect=\(rect) screen=\(screen.frame) display=\(display.frame) backing=\(backingScale) image=\(image.width)x\(image.height) scRect=\(scRect)")
                 completion(self.crop(image, to: scRect, display: display, roundedCorners: roundedCorners))
             }
         } else {

Sources/Kapture/OverlayView.swift

@@ -1,17 +1,20 @@
 import AppKit
 
+/// Renders the capture overlay. All interaction state lives in
+/// CaptureController (driven by the CGEventTap); this view only draws.
 final class OverlayWindow: NSPanel {
-    init(screen: NSScreen, onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void, onWindowPick: @escaping (NSRect) -> Void) {
+    init(screen: NSScreen, controller: CaptureController) {
-        let content = OverlayView(onComplete: onComplete, onCancel: onCancel, onWindowPick: onWindowPick)
+        let content = OverlayView()
         super.init(
             contentRect: screen.frame,
-            styleMask: [.borderless, .nonactivatingPanel],
+            styleMask: [.borderless],
             backing: .buffered,
             defer: false
         )
         contentView = content
+        content.controller = controller
         level = .screenSaver
-        collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary, .transient]
+        collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
         backgroundColor = .clear
         isOpaque = false
         hasShadow = false
@@ -23,29 +26,7 @@ final class OverlayWindow: NSPanel {
 }
 
 final class OverlayView: NSView {
-    private let onComplete: (NSRect) -> Void
+    weak var controller: CaptureController?
-    private let onCancel: () -> Void
-    private let onWindowPick: (NSRect) -> Void
-
-    private var startPoint: NSPoint?
-    private(set) var selection: NSRect?
-    private var isDragging = false
-    private var dragDistance: CGFloat = 0
-
-    // Window detection (frames stored in AppKit global space)
-    private var trackedWindows: [(id: CGWindowID, frame: NSRect)] = []
-    private var hoveredWindowFrame: NSRect?
-
-    init(onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void, onWindowPick: @escaping (NSRect) -> Void) {
-        self.onComplete = onComplete
-        self.onCancel = onCancel
-        self.onWindowPick = onWindowPick
-        super.init(frame: .zero)
-    }
-
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
 
     override var acceptsFirstResponder: Bool { true }
 
@@ -55,178 +36,56 @@ final class OverlayView: NSView {
         addCursorRect(bounds, cursor: .crosshair)
     }
 
-    // MARK: - Window detection
+    /// The screen frame this overlay covers, in AppKit global space.
-
+    private var screenFrame: NSRect {
-    /// Rebuild the list of capturable windows intersecting this screen.
+        guard let window else { return .zero }
-    /// Called lazily on mouse moves; cheap enough for interactive hover.
+        return window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
-    private func refreshTrackedWindows() {
-        guard let window = window else { return }
-        let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
-        // Exclude this overlay's own window (the other overlays don't intersect
-        // this screen, so the on-screen filter handles them).
-        let ownID = window.windowNumber
-
-        guard let list = CGWindowListCopyWindowInfo(
-            [ .optionOnScreenOnly, .excludeDesktopElements ], kCGNullWindowID
-        ) as? [[String: Any]] else { trackedWindows = []; return }
-
-        var found: [(CGWindowID, NSRect)] = []
-        for info in list {
-            guard let cid = info[kCGWindowNumber as String] as? CGWindowID,
-                  let bounds = info[kCGWindowBounds as String] as? [String: CGFloat],
-                  let layer = info[kCGWindowLayer as String] as? Int,
-                  layer == 0
-            else { continue }
-            // Skip our own overlays
-            if Int(cid) == ownID { continue }
-            let cgRect = NSRect(
-                x: bounds["X"] ?? 0,
-                y: bounds["Y"] ?? 0,
-                width: bounds["Width"] ?? 0,
-                height: bounds["Height"] ?? 0
-            )
-            guard cgRect.width >= 80, cgRect.height >= 60 else { continue }
-            // Convert to AppKit space FIRST — CG and AppKit Y axes disagree on
-            // multi-desktop layouts, so intersect tests must use one space.
-            let rect = Self.cgToAppKit(rect: cgRect)
-            // Skip windows filling the whole screen (fullscreen apps)
-            guard rect.width < screenFrame.width || rect.height < screenFrame.height else { continue }
-            // Only windows intersecting this screen
-            guard rect.intersects(screenFrame) else { continue }
-            found.append((cid, rect))
-        }
-        trackedWindows = found
     }
 
-    private func windowFrame(at point: NSPoint) -> NSRect? {
+    /// Convert an AppKit-global rect into this view's coordinates.
-        guard let window = window else { return nil }
+    private func viewRect(_ global: NSRect) -> NSRect {
-        // convertToScreen gives AppKit-global coordinates; tracked frames are
+        let sf = screenFrame
-        // already in that space.
+        return NSRect(
-        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero)).origin
+            x: global.origin.x - sf.origin.x,
-        for (_, frame) in trackedWindows {
+            y: global.origin.y - sf.origin.y,
-            if frame.contains(screenPoint) {
+            width: global.width,
-                return frame
+            height: global.height
-            }
-        }
-        return nil
-    }
-
-    /// Convert a CGWindowList (top-left origin, CG global space) frame into
-    /// AppKit screen coordinates (bottom-left origin) for capture.
-    private static func cgToAppKit(rect: NSRect) -> NSRect {
-        guard let mainScreen = NSScreen.screens.first else { return rect }
-        let y = mainScreen.frame.height - rect.origin.y - rect.height
-        return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
-    }
-
-    // MARK: - Events
-
-    override func mouseMoved(with event: NSEvent) {
-        guard !isDragging else { return }
-        refreshTrackedWindows()
-        let p = convert(event.locationInWindow, from: nil)
-        let frame = windowFrame(at: p)
-        if frame != hoveredWindowFrame {
-            hoveredWindowFrame = frame
-            needsDisplay = true
-        }
-    }
-
-    override func mouseDown(with event: NSEvent) {
-        let p = convert(event.locationInWindow, from: nil)
-        startPoint = p
-        dragDistance = 0
-        selection = NSRect(origin: p, size: .zero)
-        needsDisplay = true
-    }
-
-    override func mouseDragged(with event: NSEvent) {
-        guard let start = startPoint else { return }
-        let p = convert(event.locationInWindow, from: nil)
-        dragDistance = hypot(p.x - start.x, p.y - start.y)
-        // Only become a marquee after real movement; micro-jitter from a
-        // click must not cancel window-pick mode.
-        guard dragDistance >= 4 else { return }
-        isDragging = true
-        hoveredWindowFrame = nil
-        selection = NSRect(
-            x: min(start.x, p.x),
-            y: min(start.y, p.y),
-            width: abs(p.x - start.x),
-            height: abs(p.y - start.y)
         )
-        needsDisplay = true
-    }
-
-    override func mouseUp(with event: NSEvent) {
-        defer {
-            isDragging = false
-            dragDistance = 0
-        }
-        if isDragging {
-            guard let sel = selection else { return }
-            if sel.width >= 2, sel.height >= 2 {
-                onComplete(window!.convertToScreen(sel))
-            } else {
-                onCancel()
-            }
-            return
-        }
-
-        // It was a click. If a window is hovered, capture it with rounded
-        // corners; otherwise treat as an empty marquee (cancel).
-        if let frame = hoveredWindowFrame {
-            onWindowPick(frame)
-        } else {
-            onCancel()
-        }
-    }
-
-    override func keyDown(with event: NSEvent) {
-        if event.keyCode == 53 {
-            onCancel()
-        } else {
-            super.keyDown(with: event)
-        }
     }
 
     override func draw(_ dirtyRect: NSRect) {
         NSColor.black.withAlphaComponent(0.35).setFill()
         NSBezierPath(rect: bounds).fill()
 
-        // Highlight the hovered window (rounded, like the real window corners)
+        guard let controller else { return }
-        if let frame = hoveredWindowFrame {
+
-            // Tracked frames are AppKit-global; view space = global - window origin.
+        // Highlight the hovered window (rounded, like real window corners)
-            guard let window = window else { return }
+        if let frame = controller.hoverFrame {
-            let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
+            let vf = viewRect(frame)
-            let viewFrame = NSRect(
-                x: frame.origin.x - screenFrame.origin.x,
-                y: frame.origin.y - screenFrame.origin.y,
-                width: frame.width,
-                height: frame.height
-            )
             NSGraphicsContext.current?.saveGraphicsState()
             NSGraphicsContext.current?.compositingOperation = .clear
             NSColor.black.setFill()
-            NSBezierPath(roundedRect: viewFrame, xRadius: 10, yRadius: 10).fill()
+            NSBezierPath(roundedRect: vf, xRadius: 10, yRadius: 10).fill()
             NSGraphicsContext.current?.restoreGraphicsState()
 
-            let border = NSBezierPath(roundedRect: viewFrame, xRadius: 10, yRadius: 10)
+            let border = NSBezierPath(roundedRect: vf, xRadius: 10, yRadius: 10)
             border.lineWidth = 2
             NSColor.controlAccentColor.setStroke()
             border.stroke()
             return
         }
 
-        guard let sel = selection, sel.width > 0, sel.height > 0 else { return }
+        // Marquee selection
+        guard let sel = controller.marqueeRect, sel.width > 0, sel.height > 0 else { return }
+        let vf = viewRect(sel)
 
         NSGraphicsContext.current?.saveGraphicsState()
         NSGraphicsContext.current?.compositingOperation = .clear
         NSColor.black.setFill()
-        NSBezierPath(rect: sel).fill()
+        NSBezierPath(rect: vf).fill()
         NSGraphicsContext.current?.restoreGraphicsState()
 
-        let border = NSBezierPath(rect: sel)
+        let border = NSBezierPath(rect: vf)
         border.lineWidth = 1.5
         NSColor.controlAccentColor.setStroke()
         border.stroke()
@@ -238,8 +97,8 @@ final class OverlayView: NSView {
         ]
         let labelSize = label.size(withAttributes: attrs)
         let labelRect = NSRect(
-            x: sel.maxX - labelSize.width - 8,
+            x: vf.maxX - labelSize.width - 8,
-            y: sel.minY - labelSize.height - 10,
+            y: vf.minY - labelSize.height - 10,
             width: labelSize.width + 8,
             height: labelSize.height + 6
         )

build-app.sh

@@ -108,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.6.2</string>
+    <string>1.8.1</string>
     <key>CFBundleVersion</key>
-    <string>62</string>
+    <string>81</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>