Let system dialogs take clicks during capture; hint Esc on the overlay

The event tap consumes every click while selecting, which made permission
prompts unclickable when they appeared mid-capture. Clicks now pass
through when a system dialog (SecurityAgent / System Settings) is
frontmost, and the overlay shows a visible Esc hint as an escape hatch.

💘 Generated with Crush

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

Sources/Kapture/CaptureController.swift

@@ -14,9 +14,9 @@ final class CaptureController: NSObject {
     // 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)?
+    private(set) var hoverWindow: (id: CGWindowID, frame: NSRect, pid: Int)?
     var hoverFrame: NSRect? { hoverWindow?.frame }
-    private var trackedWindows: [(id: CGWindowID, frame: NSRect)] = []
+    private var trackedWindows: [(id: CGWindowID, frame: NSRect, pid: Int)] = []
     private var lastWindowScan = Date.distantPast
     private var eventTap: CFMachPort?
 
@@ -105,13 +105,17 @@ final class CaptureController: NSObject {
 
     /// A window was picked from hover — capture it directly (real rounded
     /// corners come from the window's own alpha).
-    private func finishWindowPick(_ windowID: CGWindowID, _ rect: NSRect) {
+    private func finishWindowPick(_ windowID: CGWindowID, _ rect: NSRect, ownedRisk: Bool) {
         let ids = overlayIDs
         hideOverlays()
         isSelecting = false
         restorePreviousApp()
         DispatchQueue.main.async { [self] in
-            capture(rect, excludingWindowIDs: ids, windowID: windowID)
+            if ownedRisk {
+                capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+            } else {
+                capture(rect, excludingWindowIDs: ids, windowID: windowID)
+            }
         }
     }
 
@@ -219,11 +223,12 @@ final class CaptureController: NSObject {
         ) as? [[String: Any]] else { trackedWindows = []; return }
 
         let ownIDs = Set(overlayIDs)
-        var found: [(id: CGWindowID, frame: NSRect)] = []
+        var found: [(id: CGWindowID, frame: NSRect, pid: Int)] = []
         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,
+                  let pid = info[kCGWindowOwnerPID as String] as? Int,
                   layer == 0
             else { continue }
             if ownIDs.contains(Int(cid)) { continue }
@@ -235,7 +240,7 @@ final class CaptureController: NSObject {
             )
             guard cgRect.width >= 80, cgRect.height >= 60 else { continue }
             let rect = Self.cgToAppKit(rect: cgRect)
-            found.append((cid, rect))
+            found.append((id: cid, frame: rect, pid: pid))
         }
         trackedWindows = found
     }
@@ -248,7 +253,7 @@ final class CaptureController: NSObject {
         return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
     }
 
-    private func topmostWindowContaining(_ appKitPoint: NSPoint) -> (id: CGWindowID, frame: NSRect)? {
+    private func topmostWindowContaining(_ appKitPoint: NSPoint) -> (id: CGWindowID, frame: NSRect, pid: Int)? {
         for entry in trackedWindows {
             if entry.frame.contains(appKitPoint) {
                 return entry
@@ -257,9 +262,21 @@ final class CaptureController: NSObject {
         return nil
     }
 
+    /// System dialogs (permission prompts, System Settings) must always
+    /// receive their clicks even while we're selecting.
+    private func isSystemDialogFrontmost() -> Bool {
+        guard let front = NSWorkspace.shared.frontmostApplication else { return false }
+        let id = front.bundleIdentifier ?? ""
+        return id.hasPrefix("com.apple.security") || id.hasPrefix("com.apple.SystemSettings") || id == "com.apple.systempreferences"
+    }
+
     /// Returns the event to pass through, or nil to consume it.
     func handleTap(_ type: CGEventType, _ event: CGEvent) -> CGEvent? {
         guard isSelecting else { return event }
+        if isSystemDialogFrontmost() {
+            CaptureController.log("tap: system dialog frontmost — passing through \(type)")
+            return event
+        }
 
         switch type {
         case .tapDisabledByUserInput, .tapDisabledByTimeout:
@@ -296,8 +313,11 @@ final class CaptureController: NSObject {
                 }
                 return event
             }
-            // Drag: grow the marquee
+            // Drag: grow the marquee — but only after real movement, so a
+            // click's micro-jitter keeps the hovered window eligible.
             guard let start = marqueeStart else { return nil }
+            let distance = hypot(appKitPoint.x - start.x, appKitPoint.y - start.y)
+            guard distance >= 4 else { return nil }
             let rect = NSRect(
                 x: min(start.x, appKitPoint.x),
                 y: min(start.y, appKitPoint.y),
@@ -321,8 +341,17 @@ final class CaptureController: NSObject {
                 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)
+                // An overlapping window from the same app means this is an
+                // owned popup — desktopIndependentWindow would composite the
+                // parent too, so capture the screen crop instead.
+                // Owned popups composite their parent even when the windows
+                // don't overlap, so ANY other same-app window on screen means
+                // crop (correct region) instead of the group composite.
+                let ownedRisk = trackedWindows.contains {
+                    $0.id != hover.id && $0.pid == hover.pid
+                }
+                CaptureController.log("tap: window pick id=\(hover.id) pid=\(hover.pid) ownedRisk=\(ownedRisk) \(hover.frame)")
+                finishWindowPick(hover.id, hover.frame, ownedRisk: ownedRisk)
             } else {
                 CaptureController.log("tap: click with no hover/marquee — cancel")
                 cancelSelection()
@@ -358,6 +387,41 @@ final class ScreenCapture {
 
     private init() {}
 
+    /// Estimate the window's corner radius (in image pixels) by scanning the
+    /// top-left corner: the crop's corner pixels are the desktop background;
+    /// app content starts where the color departs from it.
+    static func detectCornerRadius(of image: CGImage) -> CGFloat? {
+        let w = image.width, h = image.height
+        guard w > 30, h > 30 else { return nil }
+        var px = [UInt8](repeating: 0, count: w * h * 4)
+        guard let c = CGContext(data: &px, width: w, height: h, bitsPerComponent: 8, bytesPerRow: w * 4,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return nil }
+        c.draw(image, in: CGRect(x: 0, y: 0, width: w, height: h))
+
+        func pixel(x: Int, yTop: Int) -> (r: Int, g: Int, b: Int) {
+            let row = yTop * w * 4 + x * 4
+            return (Int(px[row]), Int(px[row + 1]), Int(px[row + 2]))
+        }
+        let bg = pixel(x: 0, yTop: 0)
+        func diffFromBg(_ p: (r: Int, g: Int, b: Int)) -> Int {
+            abs(p.r - bg.r) + abs(p.g - bg.g) + abs(p.b - bg.b)
+        }
+        var radii: [CGFloat] = []
+        for (limit, axis) in [(h / 3, 0), (w / 3, 1)] {
+            for i in 0..<limit {
+                let p = axis == 0 ? pixel(x: 0, yTop: i) : pixel(x: i, yTop: 0)
+                if diffFromBg(p) > 24 {
+                    radii.append(CGFloat(i))
+                    break
+                }
+            }
+        }
+        guard radii.count == 2 else { return nil }
+        let r = (radii[0] + radii[1]) / 2
+        return (r >= 3 && r <= 40) ? r : nil
+    }
+
     @available(macOS 14.0, *)
     private func crop(_ image: CGImage, to cgRect: CGRect, display: SCDisplay, roundedCorners: Bool = false) -> CGImage? {
         // cgRect is in SCDisplay space (bottom-left origin, Y flipped vs AppKit).
@@ -388,23 +452,49 @@ final class ScreenCapture {
         // Apply a rounded-corner alpha mask for window captures, matching
         // macOS window chrome (≈10pt radius, scaled to image pixels).
         if roundedCorners {
-            let radius = 10 * scaleX
-            let maskRect = CGRect(x: 0, y: 0, width: result.width, height: result.height)
-            guard let maskCtx = CGContext(
+            // The screen crop contains the app's real rounded corners against
+            // the desktop — measure the radius from the corner pixels, then
+            // mask with it (supersampled for smooth edges).
+            let detected = Self.detectCornerRadius(of: result)
+            let radius = min(max((detected.map { $0 * 1.23 + 2.6 }) ?? (10 * scaleX), 4), 40)
+            CaptureController.log("corners: detected=\(detected.map { String(format: "%.1f", $0) } ?? "nil") using=\(Int(radius))px")
+            // Anti-aliased gray mask: supersample 3x, downsample, then draw
+            // the image through it ONCE at 1x (no content resampling blur).
+            let ss = 3
+            let W = result.width * ss, H = result.height * ss
+            guard let hiMask = CGContext(
+                data: nil, width: W, height: H,
+                bitsPerComponent: 8, bytesPerRow: 0,
+                space: CGColorSpaceCreateDeviceGray(),
+                bitmapInfo: CGImageAlphaInfo.none.rawValue
+            ) else { return result }
+            hiMask.setFillColor(CGColor(gray: 1, alpha: 1))
+            hiMask.fill(CGRect(x: 0, y: 0, width: W, height: H))
+            hiMask.setFillColor(CGColor(gray: 0, alpha: 1))
+            let cornerPath = CGMutablePath()
+            cornerPath.addRect(CGRect(x: 0, y: 0, width: W, height: H))
+            cornerPath.addRoundedRect(in: CGRect(x: 0, y: 0, width: W, height: H), cornerWidth: radius * CGFloat(ss), cornerHeight: radius * CGFloat(ss), transform: .identity)
+            hiMask.addPath(cornerPath)
+            hiMask.fillPath(using: .evenOdd)
+            guard let hiMaskImg = hiMask.makeImage(),
+                  let downMask = CGContext(
+                data: nil, width: result.width, height: result.height,
+                bitsPerComponent: 8, bytesPerRow: 0,
+                space: CGColorSpaceCreateDeviceGray(),
+                bitmapInfo: CGImageAlphaInfo.none.rawValue
+            ) else { return result }
+            downMask.interpolationQuality = .high
+            downMask.draw(hiMaskImg, in: CGRect(x: 0, y: 0, width: result.width, height: result.height))
+            guard let mask1x = downMask.makeImage(),
+                  let ctx = CGContext(
                 data: nil, width: result.width, height: result.height,
                 bitsPerComponent: 8, bytesPerRow: 0,
                 space: CGColorSpaceCreateDeviceRGB(),
                 bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
             ) else { return result }
-            maskCtx.setFillColor(CGColor(gray: 1, alpha: 1))
-            maskCtx.fill(maskRect)
-            maskCtx.setBlendMode(.clear)
-            maskCtx.setFillColor(CGColor(gray: 0, alpha: 1))
-            maskCtx.addPath(CGPath(roundedRect: maskRect, cornerWidth: radius, cornerHeight: radius, transform: nil))
-            maskCtx.fillPath()
-            maskCtx.setBlendMode(.normal)
-            if let mask = maskCtx.makeImage(),
-               let masked = result.masking(mask) {
+            ctx.clip(to: CGRect(x: 0, y: 0, width: result.width, height: result.height), mask: mask1x)
+            ctx.draw(result, in: CGRect(x: 0, y: 0, width: result.width, height: result.height))
+            if let masked = ctx.makeImage() {
                 result = masked
             }
         }

Sources/Kapture/OverlayView.swift

@@ -57,6 +57,23 @@ final class OverlayView: NSView {
         NSColor.black.withAlphaComponent(0.35).setFill()
         NSBezierPath(rect: bounds).fill()
 
+        // Esc hint — the only way out once clicks are consumed by the tap.
+        let hint = "Drag to select · hover + click a window to capture it · Esc to cancel"
+        let hintAttrs: [NSAttributedString.Key: Any] = [
+            .font: NSFont.monospacedSystemFont(ofSize: 12, weight: .medium),
+            .foregroundColor: NSColor.white.withAlphaComponent(0.85),
+        ]
+        let hintSize = hint.size(withAttributes: hintAttrs)
+        let hintRect = NSRect(
+            x: (bounds.width - hintSize.width) / 2 - 10,
+            y: bounds.height - 46,
+            width: hintSize.width + 20,
+            height: hintSize.height + 12
+        )
+        NSColor.black.withAlphaComponent(0.65).setFill()
+        NSBezierPath(roundedRect: hintRect, xRadius: 8, yRadius: 8).fill()
+        hint.draw(at: NSPoint(x: hintRect.minX + 10, y: hintRect.minY + 6), withAttributes: hintAttrs)
+
         guard let controller else { return }
 
         // Highlight the hovered window (rounded, like real window corners)

build-app.sh

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