Make exported stroke thickness match the preview

Strokes were sized in view points but exported in image pixels, so on
retina captures the saved/copied annotation looked several times thinner.
Stroke widths are now converted into image pixels when drawn and scaled
back for the preview, keeping preview and export identical.

💘 Generated with Crush

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

Sources/Kapture/App.swift

@@ -119,33 +119,47 @@ enum LoginItem {
     }
 }
 
-func runOCRSelfTest() {
+func renderTestImage(_ text: String, fontSize: CGFloat = 56) -> CGImage? {
-    let text = "Kapture OCR test 1234, hello world"
+    let size = NSSize(width: 1900, height: 220)
-    let size = NSSize(width: 1600, 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)")
-        print("got:      \(recognized)")
-        let ok = recognized == text
-        print(ok ? "PASS" : "FAIL")
-        exit(ok ? 0 : 1)
 }
+
+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

@@ -84,21 +84,26 @@ final class CaptureController: NSObject {
         }
         isSelecting = true
         previousApp = NSWorkspace.shared.frontmostApplication
-        // Activation is async on macOS 26; wait a tick so the app is active
+        // With the event tap driving input we must NOT activate: stealing
-        // before the overlays appear (otherwise clicks pass through).
+        // 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: usesTap=\(usesTap) active=\(NSApp.isActive)")
         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
                 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()
         }
     }
@@ -262,9 +267,21 @@ final class CaptureController: NSObject {
         return nil
     }
 
+    /// System dialogs (permission prompts, System Settings) must always
+    /// receive their clicks even while we're selecting.
+    private func isSystemDialogFrontmost() -> Bool {
+        guard let front = NSWorkspace.shared.frontmostApplication else { return false }
+        let id = front.bundleIdentifier ?? ""
+        return id.hasPrefix("com.apple.security") || id.hasPrefix("com.apple.SystemSettings") || id == "com.apple.systempreferences"
+    }
+
     /// Returns the event to pass through, or nil to consume it.
     func handleTap(_ type: CGEventType, _ event: CGEvent) -> CGEvent? {
         guard isSelecting else { return event }
+        if isSystemDialogFrontmost() {
+            CaptureController.log("tap: system dialog frontmost — passing through \(type)")
+            return event
+        }
 
         switch type {
         case .tapDisabledByUserInput, .tapDisabledByTimeout:
@@ -301,8 +318,11 @@ final class CaptureController: NSObject {
                 }
                 return event
             }
-            // Drag: grow the marquee
+            // Drag: grow the marquee — but only after real movement, so a
+            // click's micro-jitter keeps the hovered window eligible.
             guard let start = marqueeStart else { return nil }
+            let distance = hypot(appKitPoint.x - start.x, appKitPoint.y - start.y)
+            guard distance >= 4 else { return nil }
             let rect = NSRect(
                 x: min(start.x, appKitPoint.x),
                 y: min(start.y, appKitPoint.y),
@@ -372,6 +392,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).
@@ -402,23 +457,49 @@ final class ScreenCapture {
         // Apply a rounded-corner alpha mask for window captures, matching
         // macOS window chrome (≈10pt radius, scaled to image pixels).
         if roundedCorners {
-            let radius = 10 * scaleX
+            // The screen crop contains the app's real rounded corners against
-            let maskRect = CGRect(x: 0, y: 0, width: result.width, height: result.height)
+            // the desktop — measure the radius from the corner pixels, then
-            guard let maskCtx = CGContext(
+            // 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))
+            ctx.clip(to: CGRect(x: 0, y: 0, width: result.width, height: result.height), mask: mask1x)
-            maskCtx.fill(maskRect)
+            ctx.draw(result, in: CGRect(x: 0, y: 0, width: result.width, height: result.height))
-            maskCtx.setBlendMode(.clear)
+            if let masked = ctx.makeImage() {
-            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) {
                 result = masked
             }
         }

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

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
+            // Redaction: a filled black bar from start to end.
-            // current stroke width (drawn as a rect for clean edges).
+            strokes.append(Stroke(points: points, width: max(widthPx, 12), color: .black, isRedaction: true))
-            strokes.append(Stroke(points: points, width: max(strokeWidth, 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.8.3</string>
+    <string>1.9.2</string>
     <key>CFBundleVersion</key>
-    <string>83</string>
+    <string>92</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>