Fix supersample blur and click-cancellation on micro-drags

The 3x supersample resized the whole capture (blurring content); only the
corner mask is supersampled now, applied through clip(to😷) with the
image drawn once at native scale. The tap's drag branch also clears the
hovered window on sub-4px jitter, cancelling click-to-capture; the
threshold is applied there too.

💘 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
@@ -296,8 +301,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 +329,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 +375,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 +440,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
             }
         }

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.6</string>
     <key>CFBundleVersion</key>
-    <string>81</string>
+    <string>86</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>