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

@@ -21,7 +21,19 @@ 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.onFrozenTrigger = { CaptureController.shared.begin(frozen: true) }
         HotkeyManager.shared.register()
     }
 }
@@ -33,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()
@@ -79,6 +94,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 {
@@ -101,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()
-
-    guard let cgImage = rep.cgImage else { exit(1) }
-    OCRService.shared.recognize(cgImage) { recognized in
-        print("expected: \(text)")
-        print("got:      \(recognized)")
-        let ok = recognized == text
-        print(ok ? "PASS" : "FAIL")
-        exit(ok ? 0 : 1)
+    return rep.cgImage
 }
+
+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.contains(current.contains)
+            print(ok ? "PASS" : "FAIL")
+            if !ok { exit(1) }
+            runNext()
+        }
+    }
+    runNext()
     RunLoop.main.run()
 }

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, 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?
+
     /// 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)
-        if sessionLog.count > 100 { sessionLog.removeFirst() }
+        let stamped = String(format: "%@ %@", DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .medium), line)
+        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,50 +74,107 @@ final class CaptureController: NSObject {
         return lines.joined(separator: "\n")
     }
 
-    func begin() {
+    // MARK: - Session lifecycle
+
+    /// 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
-        // Force activation: cooperative NSApp.activate() can silently fail for
-        // LSUIElement apps, leaving the app inactive — then clicks on the
-        // overlays pass through to the windows below.
+        // 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: creating overlays for \(NSScreen.screens.count) screens")
-        overlays = NSScreen.screens.map { screen in
-            OverlayWindow(
-                screen: screen,
-                onComplete: { [weak self] rect in self?.finishSelection(rect) },
-                onCancel: { [weak self] in self?.cancelSelection() },
-                onWindowPick: { [weak self] rect in self?.finishWindowPick(rect) }
-            )
         }
-        overlays.forEach { $0.makeKeyAndOrderFront(nil) }
-        overlayIDs = overlays.map { $0.windowNumber }
-        CaptureController.log("begin: \(overlays.count) overlays, ids=\(overlayIDs), 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()
+        }
     }
 
-    /// A window was picked from hover — capture it with rounded corners.
-    private func finishWindowPick(_ rect: NSRect) {
+    private func showOverlays() {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
+            guard let self, self.isSelecting else { return }
+            self.overlays = NSScreen.screens.map { screen in
+                let panel = OverlayWindow(screen: screen, 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
+            }
+            // 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) — prior app stays focused")
+            self.installEventTap()
+        }
+    }
+
+    /// 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)
         }
@@ -109,8 +187,14 @@ final class CaptureController: NSObject {
     }
 
     private func hideOverlays() {
+        removeEventTap()
         overlays.forEach { $0.orderOut(nil) }
         overlays = []
+        marqueeRect = nil
+        hoverWindow = nil
+        marqueeStart = nil
+        frozenSnapshots = []
+        isFrozenMode = false
     }
 
     private func restorePreviousApp() {
@@ -118,8 +202,226 @@ final class CaptureController: NSObject {
         previousApp = nil
     }
 
-    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 renderOverlays() {
+        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, 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 }
+            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((id: cid, frame: rect, pid: pid))
+        }
+        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, 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:
+            // 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 {
+                // 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 — 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),
+                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 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()
+            }
+            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 +430,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)
                 }
             }
@@ -140,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).
@@ -170,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)
@@ -203,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,
@@ -226,7 +658,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 +670,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/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

@@ -1,17 +1,23 @@
 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) {
-        let content = OverlayView(onComplete: onComplete, onCancel: onCancel, onWindowPick: onWindowPick)
+    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, .nonactivatingPanel],
             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 +29,10 @@ final class OverlayWindow: NSPanel {
 }
 
 final class OverlayView: NSView {
-    private let onComplete: (NSRect) -> Void
-    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")
-    }
+    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 }
 
@@ -55,178 +42,133 @@ 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 {
+        guard let window else { return .zero }
+        return window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
+    }
 
-    /// Rebuild the list of capturable windows intersecting this screen.
-    /// Called lazily on mouse moves; cheap enough for interactive hover.
-    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
+    /// Convert an AppKit-global rect into this view's coordinates.
+    private func viewRect(_ global: NSRect) -> NSRect {
+        let sf = screenFrame
+        return NSRect(
+            x: global.origin.x - sf.origin.x,
+            y: global.origin.y - sf.origin.y,
+            width: global.width,
+            height: global.height
         )
-            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? {
-        guard let window = window else { return nil }
-        // convertToScreen gives AppKit-global coordinates; tracked frames are
-        // already in that space.
-        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero)).origin
-        for (_, frame) in trackedWindows {
-            if frame.contains(screenPoint) {
-                return frame
-            }
-        }
-        return nil
+    /// 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()
     }
 
-    /// 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)
+    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
         )
-        needsDisplay = true
+        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 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))
+    override func draw(_ dirtyRect: NSRect) {
+        if let frozenImage {
+            drawFrozen(frozenImage)
         } else {
-                onCancel()
+            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
         }
 
-        // 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)
-        if let frame = hoveredWindowFrame {
-            // Tracked frames are AppKit-global; view space = global - window origin.
-            guard let window = window else { return }
-            let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
-            let viewFrame = NSRect(
-                x: frame.origin.x - screenFrame.origin.x,
-                y: frame.origin.y - screenFrame.origin.y,
-                width: frame.width,
-                height: frame.height
-            )
+        // Highlight the hovered window (rounded, like real window corners)
+        if let frame = controller.hoverFrame {
+            let vf = viewRect(frame)
             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 +180,8 @@ final class OverlayView: NSView {
         ]
         let labelSize = label.size(withAttributes: attrs)
         let labelRect = NSRect(
-            x: sel.maxX - labelSize.width - 8,
-            y: sel.minY - labelSize.height - 10,
+            x: vf.maxX - labelSize.width - 8,
+            y: vf.minY - labelSize.height - 10,
             width: labelSize.width + 8,
             height: labelSize.height + 6
         )

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.6.2</string>
+    <string>1.10.0</string>
     <key>CFBundleVersion</key>
-    <string>62</string>
+    <string>100</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>