Add frozen-screen capture on Ctrl+Shift+Cmd+S

A second hotkey snapshots every display the moment it is pressed and
shows that still image as the overlay, so the pointer and hover states
(tooltips, open menus) are captured. Selection is marquee-only — no
window detection — and the result is cropped from the snapshot rather
than recaptured, keeping the frame exactly as it was.

💘 Generated with Crush

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

Sources/Kapture/App.swift

@@ -33,6 +33,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
             }
         }
         HotkeyManager.shared.onTrigger = { CaptureController.shared.begin() }
+        HotkeyManager.shared.onFrozenTrigger = { CaptureController.shared.begin(frozen: true) }
         HotkeyManager.shared.register()
     }
 }
@@ -44,6 +45,9 @@ struct MenuView: View {
         Button("Capture & OCR") { CaptureController.shared.begin() }
             .keyboardShortcut("s", modifiers: [.command, .shift])
 
+        Button("Capture Frozen Screen") { CaptureController.shared.begin(frozen: true) }
+            .keyboardShortcut("s", modifiers: [.command, .shift, .control])
+
         Button("Extract from Image File…") { ResultWindow.shared.showOpenPanel() }
 
         Divider()
@@ -119,33 +123,47 @@ enum LoginItem {
     }
 }
 
-func runOCRSelfTest() {
-    let text = "Kapture OCR test 1234, hello world"
-    let size = NSSize(width: 1600, height: 220)
+func renderTestImage(_ text: String, fontSize: CGFloat = 56) -> CGImage? {
+    let size = NSSize(width: 1900, height: 220)
     guard let rep = NSBitmapImageRep(
         bitmapDataPlanes: nil, pixelsWide: Int(size.width), pixelsHigh: Int(size.height),
         bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false,
         colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0
-    ) else { exit(1) }
-
+    ) else { return nil }
     NSGraphicsContext.saveGraphicsState()
     NSGraphicsContext.current = NSGraphicsContext(bitmapImageRep: rep)
     NSColor.white.setFill()
     NSRect(origin: .zero, size: size).fill()
     let attrs: [NSAttributedString.Key: Any] = [
-        .font: NSFont.boldSystemFont(ofSize: 56),
+        .font: NSFont.systemFont(ofSize: fontSize),
         .foregroundColor: NSColor.black,
     ]
     text.draw(at: NSPoint(x: 60, y: 75), withAttributes: attrs)
     NSGraphicsContext.restoreGraphicsState()
+    return rep.cgImage
+}
 
-    guard let cgImage = rep.cgImage else { exit(1) }
-    OCRService.shared.recognize(cgImage) { recognized in
-        print("expected: \(text)")
+func runOCRSelfTest() {
+    let cases: [(expected: String, contains: String)] = [
+        ("Kapture OCR test 1234, hello world", "Kapture OCR test 1234"),
+        ("你好世界，这是一个测试", "你好世界"),
+    ]
+    var index = 0
+
+    func runNext() {
+        guard index < cases.count else { exit(0) }
+        let current = cases[index]
+        index += 1
+        guard let image = renderTestImage(current.expected) else { exit(1) }
+        OCRService.shared.recognize(image) { recognized in
+            print("case:     \(current.expected)")
             print("got:      \(recognized)")
-        let ok = recognized == text
+            let ok = recognized.contains(current.contains)
             print(ok ? "PASS" : "FAIL")
-        exit(ok ? 0 : 1)
+            if !ok { exit(1) }
+            runNext()
         }
+    }
+    runNext()
     RunLoop.main.run()
 }

Sources/Kapture/CaptureController.swift

@@ -14,8 +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 hoverFrame: NSRect?
-    private var trackedWindows: [(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, pid: Int)] = []
     private var lastWindowScan = Date.distantPast
     private var eventTap: CFMachPort?
 
@@ -75,51 +76,105 @@ final class CaptureController: NSObject {
 
     // MARK: - Session lifecycle
 
-    func begin() {
+    /// Frozen mode: the screen is snapshotted at hotkey press, so the pointer
+    /// and any hover state (tooltips, open menus) end up in the capture.
+    private(set) var isFrozenMode = false
+    private var frozenSnapshots: [ScreenCapture.DisplaySnapshot] = []
+
+    func begin(frozen: Bool = false) {
         guard !isSelecting else { return }
         guard PermissionManager.isGranted else {
             PermissionManager.request()
             return
         }
         isSelecting = true
+        isFrozenMode = frozen
         previousApp = NSWorkspace.shared.frontmostApplication
-        // Activation is async on macOS 26; wait a tick so the app is active
-        // before the overlays appear (otherwise clicks pass through).
+        // With the event tap driving input we must NOT activate: stealing
+        // focus turns the target app into background mode (dimmed chrome),
+        // and that is what would end up in the screenshot. Activate only on
+        // the fallback path, where panel events are the only input.
+        let usesTap = AXIsProcessTrusted()
+        if !usesTap {
             NSApp.activate(ignoringOtherApps: true)
-        CaptureController.log("begin: activate issued, active=\(NSApp.isActive)")
+        }
+        CaptureController.log("begin: frozen=\(frozen) usesTap=\(usesTap) active=\(NSApp.isActive)")
+
+        if frozen {
+            ScreenCapture.shared.snapshotAllDisplays(includeCursor: true) { [weak self] snapshots in
+                DispatchQueue.main.async {
+                    guard let self, self.isSelecting else { return }
+                    self.frozenSnapshots = snapshots
+                    CaptureController.log("frozen: captured \(snapshots.count) displays")
+                    self.showOverlays()
+                }
+            }
+        } else {
+            showOverlays()
+        }
+    }
+
+    private func showOverlays() {
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
             guard let self, self.isSelecting else { return }
-            CaptureController.log("begin: active=\(NSApp.isActive) — showing overlays")
             self.overlays = NSScreen.screens.map { screen in
                 let panel = OverlayWindow(screen: screen, controller: self)
-                (panel.contentView as? OverlayView)?.controller = self
+                if let view = panel.contentView as? OverlayView {
+                    view.controller = self
+                    view.frozenImage = self.frozenSnapshots.first(where: { $0.frame == screen.frame })?.image
+                }
                 return panel
             }
-            self.overlays.forEach { $0.makeKeyAndOrderFront(nil) }
+            // orderFrontRegardless: show without taking key/focus.
+            self.overlays.forEach { $0.orderFrontRegardless() }
             self.overlayIDs = self.overlays.map { $0.windowNumber }
-            CaptureController.log("begin: \(self.overlays.count) overlays, ids=\(self.overlayIDs), active=\(NSApp.isActive)")
+            CaptureController.log("begin: \(self.overlays.count) overlays, ids=\(self.overlayIDs) — prior app stays focused")
             self.installEventTap()
         }
     }
 
-    /// A window was picked from hover — capture it with rounded corners.
-    private func finishWindowPick(_ rect: NSRect) {
+    /// 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, ownedRisk: Bool) {
         let ids = overlayIDs
         hideOverlays()
         isSelecting = false
         restorePreviousApp()
         DispatchQueue.main.async { [self] in
+            if ownedRisk {
                 capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+            } else {
+                capture(rect, excludingWindowIDs: ids, windowID: windowID)
+            }
         }
     }
 
     private func finishSelection(_ rect: NSRect) {
         let ids = overlayIDs
+        let frozen = frozenSnapshots
+        let wasFrozen = isFrozenMode
         hideOverlays()
         guard rect.width >= 2, rect.height >= 2 else {
             cancelSelection()
             return
         }
+
+        if wasFrozen {
+            let midpoint = NSPoint(x: rect.midX, y: rect.midY)
+            let snapshot = frozen.first(where: { $0.frame.contains(midpoint) }) ?? frozen.first
+            isSelecting = false
+            restorePreviousApp()
+            DispatchQueue.main.async { [self] in
+                if let snapshot, let image = ScreenCapture.cropFrozen(snapshot, to: rect) {
+                    CaptureController.log("frozen: cropped \(Int(rect.width))x\(Int(rect.height)) -> \(image.width)x\(image.height)")
+                    ResultWindow.shared.show(image: image)
+                } else {
+                    ResultWindow.shared.show(image: ResultWindow.failureImage("Could not crop the frozen screen."))
+                }
+            }
+            return
+        }
+
         DispatchQueue.main.async { [self] in
             capture(rect, excludingWindowIDs: ids)
         }
@@ -136,8 +191,10 @@ final class CaptureController: NSObject {
         overlays.forEach { $0.orderOut(nil) }
         overlays = []
         marqueeRect = nil
-        hoverFrame = nil
+        hoverWindow = nil
         marqueeStart = nil
+        frozenSnapshots = []
+        isFrozenMode = false
     }
 
     private func restorePreviousApp() {
@@ -217,11 +274,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 }
@@ -233,12 +291,7 @@ final class CaptureController: NSObject {
             )
             guard cgRect.width >= 80, cgRect.height >= 60 else { continue }
             let rect = Self.cgToAppKit(rect: cgRect)
-            // Skip windows filling an entire screen (fullscreen apps)
-            let coversWholeScreen = NSScreen.screens.contains { screen in
-                abs(screen.frame.width - rect.width) < 2 && abs(screen.frame.height - rect.height) < 2
-            }
-            guard !coversWholeScreen else { continue }
-            found.append((cid, rect))
+            found.append((id: cid, frame: rect, pid: pid))
         }
         trackedWindows = found
     }
@@ -251,18 +304,30 @@ final class CaptureController: NSObject {
         return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
     }
 
-    private func topmostWindowContaining(_ appKitPoint: NSPoint) -> NSRect? {
-        for (_, frame) in trackedWindows {
-            if frame.contains(appKitPoint) {
-                return frame
+    private func topmostWindowContaining(_ appKitPoint: NSPoint) -> (id: CGWindowID, frame: NSRect, pid: Int)? {
+        for entry in trackedWindows {
+            if entry.frame.contains(appKitPoint) {
+                return entry
             }
         }
         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:
@@ -287,15 +352,25 @@ final class CaptureController: NSObject {
             }
             let appKitPoint = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
             if type == .mouseMoved {
-                let frame = topmostWindowContaining(appKitPoint)
-                if frame != hoverFrame {
-                    hoverFrame = frame
+                // Frozen mode is marquee-only: no window hover detection.
+                if isFrozenMode { return event }
+                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
+            // 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),
@@ -303,7 +378,7 @@ final class CaptureController: NSObject {
                 height: abs(appKitPoint.y - start.y)
             )
             marqueeRect = rect
-            hoverFrame = nil
+            hoverWindow = nil
             renderOverlays()
             return nil
         case .leftMouseDown:
@@ -318,9 +393,21 @@ final class CaptureController: NSObject {
             if let rect = marqueeRect, dragDistance >= 4, rect.width >= 2, rect.height >= 2 {
                 CaptureController.log("tap: marquee complete \(rect)")
                 finishSelection(rect)
-            } else if let hover = hoverFrame {
-                CaptureController.log("tap: window pick \(hover)")
-                finishWindowPick(hover)
+            } else if isFrozenMode {
+                CaptureController.log("tap: frozen click without drag — cancel")
+                cancelSelection()
+            } else if let hover = hoverWindow {
+                // 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()
@@ -333,8 +420,8 @@ final class CaptureController: NSObject {
 
     // MARK: - Capture
 
-    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int], roundedCorners: Bool = false) {
-        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids, roundedCorners: roundedCorners) { [weak self] image in
+    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()
@@ -356,6 +443,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).
@@ -386,29 +508,123 @@ 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
             }
         }
         return result
     }
 
+    /// Screen frame (AppKit global points) + full-resolution image per display.
+    struct DisplaySnapshot {
+        let frame: NSRect
+        let image: CGImage
+    }
+
+    /// Snapshot every display right now. Used by frozen mode: the images are
+    /// taken before the overlay appears, so the pointer and hover states
+    /// (tooltips, menus) are baked in.
+    func snapshotAllDisplays(includeCursor: Bool, completion: @escaping ([DisplaySnapshot]) -> Void) {
+        if #available(macOS 14.0, *) {
+            Task {
+                guard let content = try? await SCShareableContent.current else {
+                    completion([])
+                    return
+                }
+                var out: [DisplaySnapshot] = []
+                for display in content.displays {
+                    guard let screen = NSScreen.screens.first(where: {
+                        (($0.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0) == display.displayID
+                    }) else { continue }
+                    let config = SCStreamConfiguration()
+                    let scale = screen.backingScaleFactor
+                    config.width = Int(CGFloat(display.width) * scale)
+                    config.height = Int(CGFloat(display.height) * scale)
+                    config.showsCursor = includeCursor
+                    let filter = SCContentFilter(display: display, excludingWindows: [])
+                    if let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config) {
+                        out.append(DisplaySnapshot(frame: screen.frame, image: image))
+                    }
+                }
+                completion(out)
+            }
+        } else {
+            var out: [DisplaySnapshot] = []
+            for screen in NSScreen.screens {
+                let cgRect = CGRect(
+                    x: screen.frame.minX,
+                    y: (NSScreen.screens.first(where: { $0.frame.origin == .zero })?.frame.height ?? screen.frame.height) - screen.frame.maxY,
+                    width: screen.frame.width,
+                    height: screen.frame.height
+                )
+                if let image = CGWindowListCreateImage(cgRect, .optionOnScreenOnly, kCGNullWindowID, [.bestResolution, .boundsIgnoreFraming]) {
+                    out.append(DisplaySnapshot(frame: screen.frame, image: image))
+                }
+            }
+            completion(out)
+        }
+    }
+
+    /// Crop a selection out of a frozen snapshot (top-left pixel space).
+    static func cropFrozen(_ snapshot: DisplaySnapshot, to rect: NSRect) -> CGImage? {
+        let scaleX = CGFloat(snapshot.image.width) / snapshot.frame.width
+        let scaleY = CGFloat(snapshot.image.height) / snapshot.frame.height
+        guard scaleX > 0, scaleY > 0 else { return nil }
+        let localX = rect.minX - snapshot.frame.minX
+        let localTopY = snapshot.frame.maxY - rect.maxY
+        let px = CGRect(
+            x: localX * scaleX,
+            y: localTopY * scaleY,
+            width: rect.width * scaleX,
+            height: rect.height * scaleY
+        )
+        let safe = px.intersection(CGRect(x: 0, y: 0, width: CGFloat(snapshot.image.width), height: CGFloat(snapshot.image.height))).integral
+        guard safe.width >= 1, safe.height >= 1 else { return nil }
+        return snapshot.image.cropping(to: safe)
+    }
+
     @available(macOS 14.0, *)
     private func displayContaining(_ rect: NSRect, in content: SCShareableContent) -> SCDisplay? {
         let mid = NSPoint(x: rect.midX, y: rect.midY)
@@ -419,7 +635,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,
@@ -454,6 +670,37 @@ 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

Sources/Kapture/HotkeyManager.swift

@@ -4,11 +4,14 @@ import AppKit
 final class HotkeyManager {
     static let shared = HotkeyManager()
 
+    /// ⌘⇧S — live capture (ScreenCaptureKit at capture time).
     var onTrigger: (() -> Void)?
+    /// ⌃⇧⌘S — frozen capture (snapshot at hotkey press).
+    var onFrozenTrigger: (() -> Void)?
 
-    private var hotKeyRef: EventHotKeyRef?
+    private var hotKeyRefs: [EventHotKeyRef?] = []
     private var eventHandlerRef: EventHandlerRef?
-    private var hotKeyID = EventHotKeyID(signature: 0x4B505452, id: 1)
+    private let signature: OSType = 0x4B505452
 
     private init() {}
 
@@ -17,18 +20,36 @@ final class HotkeyManager {
             eventClass: OSType(kEventClassKeyboard),
             eventKind: UInt32(kEventHotKeyPressed)
         )
-        InstallEventHandler(GetApplicationEventTarget(), { _, _, _ in
-            HotkeyManager.shared.onTrigger?()
+        InstallEventHandler(GetApplicationEventTarget(), { _, event, _ in
+            var hotKeyID = EventHotKeyID()
+            let status = GetEventParameter(
+                event,
+                EventParamName(kEventParamDirectObject),
+                EventParamType(typeEventHotKeyID),
+                nil,
+                MemoryLayout<EventHotKeyID>.size,
+                nil,
+                &hotKeyID
+            )
+            guard status == noErr else { return noErr }
+            DispatchQueue.main.async {
+                switch hotKeyID.id {
+                case 1: HotkeyManager.shared.onTrigger?()
+                case 2: HotkeyManager.shared.onFrozenTrigger?()
+                default: break
+                }
+            }
             return noErr
         }, 1, &eventType, nil, &eventHandlerRef)
 
-        RegisterEventHotKey(
-            UInt32(kVK_ANSI_S),
-            UInt32(cmdKey | shiftKey),
-            hotKeyID,
-            GetApplicationEventTarget(),
-            0,
-            &hotKeyRef
-        )
+        registerHotkey(id: 1, keyCode: UInt32(kVK_ANSI_S), modifiers: UInt32(cmdKey | shiftKey))
+        registerHotkey(id: 2, keyCode: UInt32(kVK_ANSI_S), modifiers: UInt32(cmdKey | shiftKey | controlKey))
+    }
+
+    private func registerHotkey(id: UInt32, keyCode: UInt32, modifiers: UInt32) {
+        var ref: EventHotKeyRef?
+        let hotKeyID = EventHotKeyID(signature: signature, id: id)
+        RegisterEventHotKey(keyCode, modifiers, hotKeyID, GetApplicationEventTarget(), 0, &ref)
+        hotKeyRefs.append(ref)
     }
 }

Sources/Kapture/OCRService.swift

@@ -12,6 +12,11 @@ final class OCRService {
             request.recognitionLevel = .accurate
             request.usesLanguageCorrection = true
             request.recognitionLanguages = ["en-US", "zh-Hans", "zh-Hant", "ja-JP", "ko-KR"]
+            // Without this, Vision defaults to the first listed language and
+            // renders CJK as Latin garbage (verified: 你好世界 -> "177WR").
+            if #available(macOS 13.0, *) {
+                request.automaticallyDetectsLanguage = true
+            }
 
             let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
             do {

Sources/Kapture/OverlayView.swift

@@ -6,8 +6,11 @@ final class OverlayWindow: NSPanel {
     init(screen: NSScreen, controller: CaptureController) {
         let content = OverlayView()
         super.init(
+            // Non-activating: the overlay must NOT steal focus, so the app
+            // being captured keeps its active appearance (undimmed chrome).
+            // Input comes from the CGEventTap, not panel events.
             contentRect: screen.frame,
-            styleMask: [.borderless],
+            styleMask: [.borderless, .nonactivatingPanel],
             backing: .buffered,
             defer: false
         )
@@ -27,6 +30,9 @@ final class OverlayWindow: NSPanel {
 
 final class OverlayView: NSView {
     weak var controller: CaptureController?
+    /// In frozen mode: the still image to display for this screen (already
+    /// full resolution). Nil = live mode (dim the real screen).
+    var frozenImage: CGImage?
 
     override var acceptsFirstResponder: Bool { true }
 
@@ -53,12 +59,89 @@ final class OverlayView: NSView {
         )
     }
 
+    /// Draw the frozen snapshot filling the screen, then replace its centre
+    /// hole with the live... no: the image IS the content, drawn opaque.
+    private func drawFrozen(_ image: CGImage) {
+        guard let ctx = NSGraphicsContext.current?.cgContext else { return }
+        ctx.saveGState()
+        ctx.interpolationQuality = .high
+        // Image is in pixels, view in points — draw into the view bounds.
+        ctx.draw(image, in: bounds)
+        ctx.restoreGState()
+    }
+
+    private func drawSizeLabel(for sel: NSRect, in vf: NSRect) {
+        let label = "\(Int(sel.width)) × \(Int(sel.height))"
+        let attrs: [NSAttributedString.Key: Any] = [
+            .font: NSFont.monospacedDigitSystemFont(ofSize: 12, weight: .medium),
+            .foregroundColor: NSColor.white,
+        ]
+        let labelSize = label.size(withAttributes: attrs)
+        let labelRect = NSRect(
+            x: vf.maxX - labelSize.width - 8,
+            y: vf.minY - labelSize.height - 10,
+            width: labelSize.width + 8,
+            height: labelSize.height + 6
+        )
+        NSColor.black.withAlphaComponent(0.6).setFill()
+        NSBezierPath(roundedRect: labelRect, xRadius: 4, yRadius: 4).fill()
+        label.draw(at: NSPoint(x: labelRect.minX + 4, y: labelRect.minY + 3), withAttributes: attrs)
+    }
+
     override func draw(_ dirtyRect: NSRect) {
+        if let frozenImage {
+            drawFrozen(frozenImage)
+        } else {
             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 }
 
+        // Frozen mode: no window highlight; the marquee is cut straight out
+        // of the still image so it shows the frozen pixels.
+        if frozenImage != nil {
+            if let sel = controller.marqueeRect, sel.width > 0, sel.height > 0 {
+                let vf = viewRect(sel)
+                // Dim everything except the selection (even-odd fill).
+                let maskPath = CGMutablePath()
+                maskPath.addRect(bounds)
+                maskPath.addRect(vf)
+                NSGraphicsContext.current?.saveGraphicsState()
+                let ctx = NSGraphicsContext.current?.cgContext
+                ctx?.addPath(maskPath)
+                ctx?.fillPath(using: .evenOdd)
+                NSColor.black.withAlphaComponent(0.35).setFill()
+                ctx?.addPath(maskPath)
+                ctx?.fillPath(using: .evenOdd)
+                NSGraphicsContext.current?.restoreGraphicsState()
+
+                let border = NSBezierPath(rect: vf)
+                border.lineWidth = 1.5
+                NSColor.controlAccentColor.setStroke()
+                border.stroke()
+                drawSizeLabel(for: sel, in: vf)
+            }
+            return
+        }
+
         // Highlight the hovered window (rounded, like real window corners)
         if let frame = controller.hoverFrame {
             let vf = viewRect(frame)

Sources/Kapture/ResultWindow.swift

@@ -195,14 +195,15 @@ final class CaptureModel: ObservableObject {
         return rep.cgImage ?? image
     }
 
-    func addStroke(_ points: [CGPoint]) {
+    /// `widthPx` is the stroke thickness in IMAGE PIXELS (the preview
+    /// converts the slider value so exports match what was drawn).
+    func addStroke(_ points: [CGPoint], widthPx: CGFloat) {
         guard points.count > 1 else { return }
         if tool == .redact {
-            // Redaction: a filled black bar from start to end, as thick as the
-            // current stroke width (drawn as a rect for clean edges).
-            strokes.append(Stroke(points: points, width: max(strokeWidth, 12), color: .black, isRedaction: true))
+            // Redaction: a filled black bar from start to end.
+            strokes.append(Stroke(points: points, width: max(widthPx, 12), color: .black, isRedaction: true))
         } else {
-            strokes.append(Stroke(points: points, width: strokeWidth, color: drawColor))
+            strokes.append(Stroke(points: points, width: widthPx, color: drawColor))
         }
         redoStack = []
     }
@@ -575,7 +576,8 @@ struct ScreenshotPane: View {
                             for point in stroke.points.dropFirst() {
                                 path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
                             }
-                            context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width)
+                            // stroke.width is in image pixels; scale to view points
+                            context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width * scale)
                         }
                     }
                 }
@@ -636,7 +638,7 @@ struct ScreenshotPane: View {
                     .onEnded { _ in
                         if model.tool != .select {
                             if currentStroke.count > 1 {
-                                model.addStroke(currentStroke)
+                                model.addStroke(currentStroke, widthPx: model.strokeWidth / max(scale, 0.01))
                             }
                             currentStroke = []
                         } else {

build-app.sh

@@ -108,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.7.3</string>
+    <string>1.10.0</string>
     <key>CFBundleVersion</key>
-    <string>73</string>
+    <string>100</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>