Add screen recording, crop, and a Cap-style result window

Recording: Ctrl+Shift+Cmd+R (or the menu) opens the same selection
flow — a marquee records that region, clicking a window records it
(following moves). Video is H.264 .mov at 60fps via SCStream ->
AVAssetWriter with the cursor included, auto-saved to ~/Movies and
revealed in Finder on stop. A red border and a floating timer/stop bar
show during recording, both excluded from the video. Audio is wired
behind a flag for later.

The result window gains a Crop button (crop to the selection;
annotations translate and stay editable) and is restyled after Cap:
sliding-pill Screenshot/Text switcher, capsule buttons in Cap blue,
circular icon buttons, and the content on a rounded card — light and
dark.

Generated with OpenCode

Assisted-by: Kimi:k3

README.md

@@ -25,11 +25,14 @@ No network calls, no API keys — everything runs locally.
 ## Install with Homebrew
 
 ```bash
-brew tap TZGyn/tap
-brew trust TZGyn/tap          # Homebrew 6+ requires trusting third-party taps
+brew tap TZGyn/tap https://gitea.tzgyn.dev/TZGyn/homebrew-tap.git
+brew trust TZGyn/tap
 brew install --cask kapture
 ```
 
+The tap is hosted on Gitea, so the full URL is required. Homebrew may print
+an "Unsupported tap" warning — it's harmless.
+
 Releases are published as zips on GitHub Releases; `release.sh` packages a
 new one (`./release.sh 1.0.1 && git tag v1.0.1 && git push origin v1.0.1`).
 The cask lives in the [TZGyn/homebrew-tap](https://github.com/TZGyn/homebrew-tap)

Sources/Kapture/App.swift

@@ -21,17 +21,54 @@ 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.onRecordTrigger = {
+            if RecordingController.shared.state.isRecording {
+                RecordingController.shared.stop()
+            } else {
+                CaptureController.shared.begin(recording: true)
+            }
+        }
         HotkeyManager.shared.register()
     }
+
+    func applicationWillTerminate(_ notification: Notification) {
+        RecordingController.shared.finalizeForTermination()
+    }
 }
 
 struct MenuView: View {
     @State private var granted = PermissionManager.isGranted
+    @ObservedObject private var recordingState = RecordingController.shared.state
 
     var body: some View {
         Button("Capture & OCR") { CaptureController.shared.begin() }
             .keyboardShortcut("s", modifiers: [.command, .shift])
+            .disabled(recordingState.isRecording)
+
+        Button("Capture Frozen Screen") { CaptureController.shared.begin(frozen: true) }
+            .keyboardShortcut("s", modifiers: [.command, .shift, .control])
+            .disabled(recordingState.isRecording)
+
+        if recordingState.isRecording {
+            Button("Stop Recording") { RecordingController.shared.stop() }
+                .keyboardShortcut("r", modifiers: [.command, .shift, .control])
+        } else {
+            Button("Record Screen…") { CaptureController.shared.begin(recording: true) }
+                .keyboardShortcut("r", modifiers: [.command, .shift, .control])
+        }
 
         Button("Extract from Image File…") { ResultWindow.shared.showOpenPanel() }
 
@@ -79,6 +116,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 +145,52 @@ 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, width: CGFloat = 1900, height: CGFloat = 220) -> CGImage? {
+    let size = NSSize(width: width, height: height)
     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)
+    // Centre the text vertically so tiny canvases still contain it.
+    let textHeight = ("Ag" as NSString).size(withAttributes: attrs).height
+    let y = max(4, (size.height - textHeight) / 2)
+    text.draw(at: NSPoint(x: 20, y: y), 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, fontSize: CGFloat, width: CGFloat, height: CGFloat)] = [
+        ("Kapture OCR test 1234, hello world", "Kapture OCR test 1234", 56, 1900, 220),
+        ("你好世界，这是一个测试", "你好世界", 56, 1900, 220),
+        // Tiny text: needs the upscale retry to read anything at all.
+        ("会话导出并发冲突报错 export fail", "导出", 7, 320, 40),
+    ]
+    var index = 0
+
+    func runNext() {
+        guard index < cases.count else { exit(0) }
+        let current = cases[index]
+        index += 1
+        guard let image = renderTestImage(current.expected, fontSize: current.fontSize, width: current.width, height: current.height) else { exit(1) }
+        OCRService.shared.recognize(image) { recognized in
+            print("case:     \(current.expected) @\(Int(current.fontSize))pt")
+            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,19 +1,51 @@
 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) {
+        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")
+        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 ---")
         for (i, s) in NSScreen.screens.enumerated() {
             let scale = s.backingScaleFactor
             let cgID = (s.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0
@@ -42,49 +74,132 @@ 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
+    /// Recording mode: the selection flow ends in a recording, not a still.
+    private(set) var isRecordingMode = false
+    private var frozenSnapshots: [ScreenCapture.DisplaySnapshot] = []
+
+    func begin(frozen: Bool = false, recording: Bool = false) {
         guard !isSelecting else { return }
+        // No new captures while a recording is running (the selection
+        // overlays would end up in the video).
+        guard !RecordingController.shared.state.isRecording else { return }
         guard PermissionManager.isGranted else {
             PermissionManager.request()
             return
         }
         isSelecting = true
+        isFrozenMode = frozen && !recording
+        isRecordingMode = recording
         previousApp = NSWorkspace.shared.frontmostApplication
-        if #available(macOS 14.0, *) {
-            NSApp.activate()
-        } else {
+        // 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)
         }
-        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) }
-            )
+        CaptureController.log("begin: frozen=\(isFrozenMode) recording=\(recording) 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()
         }
-        overlays.forEach { $0.makeKeyAndOrderFront(nil) }
-        overlayIDs = overlays.map { $0.windowNumber }
     }
 
-    /// 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
+        let recording = isRecordingMode
         hideOverlays()
         isSelecting = false
         restorePreviousApp()
+        if recording {
+            // Owned-popup risk: record the screen region instead of the
+            // window filter, which could composite the parent into the video.
+            RecordingController.shared.begin(
+                region: rect,
+                windowID: ownedRisk ? nil : windowID,
+                excludingWindowIDs: ids
+            )
+            return
+        }
         DispatchQueue.main.async { [self] in
-            capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+            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
+        let recording = isRecordingMode
         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
+        }
+
+        if recording {
+            isSelecting = false
+            restorePreviousApp()
+            RecordingController.shared.begin(region: rect, windowID: nil, excludingWindowIDs: ids)
+            return
+        }
+
         DispatchQueue.main.async { [self] in
             capture(rect, excludingWindowIDs: ids)
         }
@@ -97,8 +212,15 @@ final class CaptureController: NSObject {
     }
 
     private func hideOverlays() {
+        removeEventTap()
         overlays.forEach { $0.orderOut(nil) }
         overlays = []
+        marqueeRect = nil
+        hoverWindow = nil
+        marqueeStart = nil
+        frozenSnapshots = []
+        isFrozenMode = false
+        isRecordingMode = false
     }
 
     private func restorePreviousApp() {
@@ -106,8 +228,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()
@@ -116,6 +456,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)
                 }
             }
@@ -128,6 +469,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).
@@ -158,29 +534,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)
@@ -191,7 +661,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,
@@ -214,7 +684,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,
@@ -226,10 +696,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,16 @@ 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)?
+    /// ⌃⇧⌘R — screen recording (region or window); toggles stop.
+    var onRecordTrigger: (() -> 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 +22,38 @@ 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?()
+                case 3: HotkeyManager.shared.onRecordTrigger?()
+                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))
+        registerHotkey(id: 3, keyCode: UInt32(kVK_ANSI_R), 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

@@ -8,29 +8,66 @@ final class OCRService {
 
     func recognize(_ cgImage: CGImage, completion: @escaping (String) -> Void) {
         queue.async {
-            let request = VNRecognizeTextRequest()
-            request.recognitionLevel = .accurate
-            request.usesLanguageCorrection = true
-            request.recognitionLanguages = ["en-US", "zh-Hans", "zh-Hant", "ja-JP", "ko-KR"]
-
-            let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
-            do {
-                try handler.perform([request])
-            } catch {
-                completion("")
+            let text = Self.perform(cgImage)
+            // Tiny text (small UI labels) often reads as nothing at native
+            // size; retry upscaled and keep whichever pass read more.
+            guard text.count < 3 else {
+                completion(text)
                 return
             }
-
-            let observations = request.results ?? []
-            let lines = observations
-                .sorted { a, b in
-                    let ay = a.boundingBox.midY
-                    let by = b.boundingBox.midY
-                    if abs(ay - by) > 0.02 { return ay > by }
-                    return a.boundingBox.minX < b.boundingBox.minX
-                }
-                .compactMap { $0.topCandidates(1).first?.string }
-            completion(lines.joined(separator: "\n"))
+            var best = text
+            for factor in [CGFloat(2), CGFloat(3)] {
+                guard let upscaled = Self.upscaled(cgImage, factor: factor) else { continue }
+                let candidate = Self.perform(upscaled)
+                if candidate.count > best.count { best = candidate }
+                if best.count >= 3 { break }
+            }
+            completion(best)
         }
     }
+
+    private static func perform(_ cgImage: CGImage) -> String {
+        let request = VNRecognizeTextRequest()
+        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 {
+            try handler.perform([request])
+        } catch {
+            return ""
+        }
+
+        let observations = request.results ?? []
+        let lines = observations
+            .sorted { a, b in
+                let ay = a.boundingBox.midY
+                let by = b.boundingBox.midY
+                if abs(ay - by) > 0.02 { return ay > by }
+                return a.boundingBox.minX < b.boundingBox.minX
+            }
+            .compactMap { $0.topCandidates(1).first?.string }
+        return lines.joined(separator: "\n")
+    }
+
+    private static func upscaled(_ cgImage: CGImage, factor: CGFloat) -> CGImage? {
+        let width = Int(CGFloat(cgImage.width) * factor)
+        let height = Int(CGFloat(cgImage.height) * factor)
+        guard width > 0, height > 0, width <= 20000, height <= 20000 else { return nil }
+        guard let ctx = CGContext(
+            data: nil, width: width, height: height,
+            bitsPerComponent: 8, bytesPerRow: 0,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ) else { return nil }
+        ctx.interpolationQuality = .high
+        ctx.draw(cgImage, in: CGRect(x: 0, y: 0, width: CGFloat(width), height: CGFloat(height)))
+        return ctx.makeImage()
+    }
 }

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
-
-    // Window detection
-    private var trackedWindows: [(id: CGWindowID, frame: NSRect)] = []
-    private var hoveredWindowFrame: NSRect?
-    private var excludedIDs: [Int] = []
-
-    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,171 +42,135 @@ final class OverlayView: NSView {
         addCursorRect(bounds, cursor: .crosshair)
     }
 
-    // MARK: - Window detection
-
-    /// 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 rect = NSRect(
-                x: bounds["X"] ?? 0,
-                y: bounds["Y"] ?? 0,
-                width: bounds["Width"] ?? 0,
-                height: bounds["Height"] ?? 0
-            )
-            guard rect.width >= 80, rect.height >= 60 else { continue }
-            // Skip tiny/utility windows
-            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
+    /// 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))
     }
 
-    private func windowFrame(at point: NSPoint) -> NSRect? {
-        guard let window = window else { return nil }
-        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero))
-        // CGWindowList bounds use a TOP-LEFT origin; convert the cursor point.
-        guard let mainScreen = NSScreen.screens.first else { return nil }
-        let topLeftPoint = NSPoint(
-            x: screenPoint.origin.x,
-            y: mainScreen.frame.height - screenPoint.origin.y
+    /// 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
         )
-        // Pick the frontmost (list order) window containing the point
-        for (_, frame) in trackedWindows {
-            if frame.contains(topLeftPoint) {
-                return frame
-            }
-        }
-        return nil
     }
 
-    /// Convert a CGWindowList (top-left origin) 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)
+    /// 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()
     }
 
-    // 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
-        selection = NSRect(origin: p, size: .zero)
-        needsDisplay = true
-    }
-
-    override func mouseDragged(with event: NSEvent) {
-        guard let start = startPoint else { return }
-        isDragging = true
-        hoveredWindowFrame = nil
-        let p = convert(event.locationInWindow, from: 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) {
-        if isDragging {
-            guard let sel = selection else { return }
-            if sel.width >= 2, sel.height >= 2 {
-                onComplete(window!.convertToScreen(sel))
-            } else {
-                onCancel()
+    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: String
+        if controller?.isRecordingMode == true {
+            hint = "Drag to select · hover + click a window to record · Esc to cancel"
+        } else if frozenImage != nil {
+            hint = "Frozen screen · drag to select · Esc to cancel"
+        } else {
+            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: same look as live mode — a dark veil over everything,
+        // with the selection showing the frozen pixels undimmed.
+        if let frozenImage {
+            NSColor.black.withAlphaComponent(0.35).setFill()
+            NSBezierPath(rect: bounds).fill()
+
+            if let sel = controller.marqueeRect, sel.width > 0, sel.height > 0 {
+                let vf = viewRect(sel)
+                NSGraphicsContext.current?.saveGraphicsState()
+                NSBezierPath(rect: vf).addClip()
+                drawFrozen(frozenImage)
+                NSGraphicsContext.current?.restoreGraphicsState()
+
+                let border = NSBezierPath(rect: vf)
+                border.lineWidth = 1.5
+                NSColor.controlAccentColor.setStroke()
+                border.stroke()
+                drawSizeLabel(for: sel, in: vf)
             }
             return
         }
 
-        // No drag: 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(Self.cgToAppKit(rect: 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 {
-            // Convert CGWindowList (top-left) frame to view (bottom-left) space
-            guard let window = window, let mainScreen = NSScreen.screens.first else { return }
-            let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
-            let viewFrame = NSRect(
-                x: frame.origin.x - screenFrame.origin.x,
-                y: mainScreen.frame.height - frame.origin.y - frame.height - 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()
@@ -231,8 +182,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/RecordingController.swift

@@ -0,0 +1,181 @@
+import AppKit
+import SwiftUI
+
+/// Shared recording state, observed by the menu bar menu and control bar.
+final class RecordingState: ObservableObject {
+    @Published var isRecording = false
+    @Published var elapsed: TimeInterval = 0
+}
+
+/// Owns a recording session: the red border around the recorded region and
+/// the floating timer/stop bar. Both chrome windows are excluded from the
+/// video. On stop, the file is auto-saved to ~/Movies and revealed in Finder.
+final class RecordingController {
+    static let shared = RecordingController()
+
+    let state = RecordingState()
+
+    private var recorder: ScreenRecorder?
+    private var chromeWindows: [NSWindow] = []
+    private var timer: Timer?
+
+    /// `region` is in AppKit global points; `windowID` records that window
+    /// instead of the region. Called by CaptureController after the
+    /// selection overlays are hidden.
+    func begin(region: NSRect, windowID: CGWindowID?, excludingWindowIDs: [Int]) {
+        guard !state.isRecording else { return }
+        showChrome(region: region)
+        let excluded = excludingWindowIDs + chromeWindows.map { $0.windowNumber }
+        state.isRecording = true
+
+        let recorder = ScreenRecorder()
+        self.recorder = recorder
+        // Give the window server a beat so the chrome shows up in the
+        // shareable-content snapshot and gets excluded from the video.
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) { [weak self] in
+            guard let self, self.recorder === recorder else { return }
+            recorder.start(region: region, windowID: windowID, excludingWindowIDs: excluded) { [weak self] ok in
+                DispatchQueue.main.async {
+                    guard let self else { return }
+                    if ok {
+                        self.startTimer()
+                    } else {
+                        self.finish(url: nil)
+                        ResultWindow.shared.show(image: ResultWindow.failureImage("Could not start the recording. Check Screen Recording permission."))
+                    }
+                }
+            }
+        }
+    }
+
+    func stop() {
+        guard state.isRecording else { return }
+        state.isRecording = false
+        timer?.invalidate()
+        timer = nil
+        recorder?.stop { [weak self] url in
+            DispatchQueue.main.async { self?.finish(url: url) }
+        }
+    }
+
+    /// Best-effort finalize on quit so the .mov isn't left truncated.
+    /// Blocks briefly — only call from applicationWillTerminate.
+    func finalizeForTermination() {
+        guard let recorder else { return }
+        let semaphore = DispatchSemaphore(value: 0)
+        recorder.stop { _ in semaphore.signal() }
+        _ = semaphore.wait(timeout: .now() + 3)
+    }
+
+    private func finish(url: URL?) {
+        state.isRecording = false
+        hideChrome()
+        recorder = nil
+        state.elapsed = 0
+        if let url {
+            CaptureController.log("rec: saved \(url.path)")
+            NSWorkspace.shared.activateFileViewerSelecting([url])
+        }
+    }
+
+    private func startTimer() {
+        let started = Date()
+        state.elapsed = 0
+        timer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] _ in
+            self?.state.elapsed = Date().timeIntervalSince(started)
+        }
+    }
+
+    // MARK: - Chrome
+
+    private func showChrome(region: NSRect) {
+        // Red border around the recorded region.
+        let border = NSPanel(
+            contentRect: region,
+            styleMask: [.borderless, .nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+        border.level = .screenSaver
+        border.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
+        border.backgroundColor = .clear
+        border.isOpaque = false
+        border.hasShadow = false
+        border.ignoresMouseEvents = true
+        border.contentView = RecordingBorderView()
+        border.orderFrontRegardless()
+
+        // Floating timer/stop bar at the bottom centre of the region.
+        let bar = NSPanel(
+            contentRect: .zero,
+            styleMask: [.borderless, .nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+        bar.level = .screenSaver
+        bar.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
+        bar.backgroundColor = .clear
+        bar.isOpaque = false
+        bar.hasShadow = false
+        let hosting = NSHostingView(rootView: RecordingBarView(state: state) { [weak self] in
+            self?.stop()
+        })
+        let size = hosting.fittingSize
+        bar.setContentSize(size)
+        bar.setFrameOrigin(NSPoint(x: region.midX - size.width / 2, y: region.minY + 14))
+        bar.contentView = hosting
+        bar.orderFrontRegardless()
+
+        chromeWindows = [border, bar]
+    }
+
+    private func hideChrome() {
+        chromeWindows.forEach { $0.orderOut(nil) }
+        chromeWindows = []
+    }
+}
+
+/// Draws the red rounded border around the recorded region.
+private final class RecordingBorderView: NSView {
+    override func draw(_ dirtyRect: NSRect) {
+        let path = NSBezierPath(roundedRect: bounds.insetBy(dx: 2, dy: 2), xRadius: 8, yRadius: 8)
+        NSColor.systemRed.setStroke()
+        path.lineWidth = 3
+        path.stroke()
+    }
+}
+
+/// The floating capsule bar: red dot, elapsed time, stop button.
+struct RecordingBarView: View {
+    @ObservedObject var state: RecordingState
+    let onStop: () -> Void
+
+    private var timeString: String {
+        let total = Int(state.elapsed)
+        return String(format: "%02d:%02d", total / 60, total % 60)
+    }
+
+    var body: some View {
+        HStack(spacing: 10) {
+            Circle()
+                .fill(Color.red)
+                .frame(width: 8, height: 8)
+            Text(timeString)
+                .font(.system(size: 12, weight: .medium).monospacedDigit())
+                .foregroundStyle(.white)
+            Button(action: onStop) {
+                Image(systemName: "stop.fill")
+                    .font(.system(size: 10, weight: .bold))
+                    .foregroundStyle(.white)
+                    .frame(width: 22, height: 22)
+                    .background(Circle().fill(Color.red))
+                    .contentShape(Circle())
+            }
+            .buttonStyle(.plain)
+            .help("Stop recording (⌃⇧⌘R)")
+        }
+        .padding(.horizontal, 12)
+        .padding(.vertical, 7)
+        .background(Capsule().fill(Color.black.opacity(0.78)))
+    }
+}

Sources/Kapture/ResultWindow.swift

@@ -82,7 +82,7 @@ final class ResultWindow {
 
 @MainActor
 final class CaptureModel: ObservableObject {
-    let image: CGImage
+    @Published var image: CGImage
 
     @Published var mode: CaptureMode = .screenshot
     @Published var extractedText: String?
@@ -95,16 +95,23 @@ final class CaptureModel: ObservableObject {
     /// Redo stack of removed strokes
     @Published var redoStack: [Stroke] = []
     /// Whether the pen is active (drag draws instead of selecting)
-    @Published var isDrawing = false
+    @Published var tool: Tool = .select
     /// Current drawing color
     @Published var drawColor: NSColor = .systemRed
     /// Stroke thickness in points (image space)
     @Published var strokeWidth: CGFloat = 3.0
 
+    enum Tool {
+        case select
+        case draw
+        case redact
+    }
+
     struct Stroke {
         let points: [CGPoint]
         let width: CGFloat
         let color: NSColor
+        var isRedaction: Bool = false
     }
 
     enum CaptureMode {
@@ -159,23 +166,45 @@ final class CaptureModel: ObservableObject {
         ctx.setLineJoin(.round)
         for stroke in strokes {
             guard stroke.points.count > 1 else { continue }
-            stroke.color.setStroke()
-            ctx.setLineWidth(stroke.width)
-            ctx.beginPath()
-            ctx.move(to: stroke.points[0])
-            for point in stroke.points.dropFirst() {
-                ctx.addLine(to: point)
+            if stroke.isRedaction {
+                // Redaction bar: filled black rect covering the stroke bounds,
+                // padded so it fully covers text.
+                let xs = stroke.points.map { $0.x }
+                let ys = stroke.points.map { $0.y }
+                let bar = NSRect(
+                    x: xs.min()! - 2,
+                    y: ys.min()! - 2,
+                    width: (xs.max()! - xs.min()!) + 4,
+                    height: max(stroke.width, ys.max()! - ys.min()!) + 4
+                )
+                NSColor.black.setFill()
+                NSBezierPath(rect: bar).fill()
+            } else {
+                stroke.color.setStroke()
+                ctx.setLineWidth(stroke.width)
+                ctx.beginPath()
+                ctx.move(to: stroke.points[0])
+                for point in stroke.points.dropFirst() {
+                    ctx.addLine(to: point)
+                }
+                ctx.strokePath()
             }
-            ctx.strokePath()
         }
         ctx.restoreGState()
         NSGraphicsContext.restoreGraphicsState()
         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 }
-        strokes.append(Stroke(points: points, width: strokeWidth, color: drawColor))
+        if tool == .redact {
+            // 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: widthPx, color: drawColor))
+        }
         redoStack = []
     }
 
@@ -186,8 +215,36 @@ final class CaptureModel: ObservableObject {
         return extractedText ?? "Select text in the screenshot, then click “Get Text”."
     }
 
-    func cropImage(to rectInImage: CGRect) -> CGImage? {
-        return image.cropping(to: rectInImage)
+    /// Crop the image to `rectInImage` (image pixel space). Strokes are
+    /// translated into the new coordinate space; strokes fully outside the
+    /// crop are dropped. Selection is cleared.
+    func crop(to rectInImage: CGRect) {
+        let bounds = CGRect(origin: .zero, size: CGSize(width: image.width, height: image.height))
+        let rect = rectInImage.integral.intersection(bounds)
+        guard rect.width >= 2, rect.height >= 2, rect != bounds,
+              let cropped = image.cropping(to: rect) else { return }
+        image = cropped
+        let newBounds = CGRect(origin: .zero, size: rect.size)
+        func translated(_ stroke: Stroke) -> Stroke? {
+            let points = stroke.points.map { CGPoint(x: $0.x - rect.minX, y: $0.y - rect.minY) }
+            let xs = points.map { $0.x }
+            let ys = points.map { $0.y }
+            let strokeBounds = CGRect(
+                x: xs.min()!, y: ys.min()!,
+                width: xs.max()! - xs.min()!, height: ys.max()! - ys.min()!
+            ).insetBy(dx: -stroke.width, dy: -stroke.width)
+            guard strokeBounds.intersects(newBounds) else { return nil }
+            return Stroke(points: points, width: stroke.width, color: stroke.color, isRedaction: stroke.isRedaction)
+        }
+        strokes = strokes.compactMap(translated)
+        redoStack = redoStack.compactMap(translated)
+        selection = nil
+        statusMessage = "Cropped to \(Int(rect.width))×\(Int(rect.height))."
+    }
+
+    func cropToSelection() {
+        guard let sel = selection, hasSelection else { return }
+        crop(to: sel)
     }
 
     func runOCR(over selectionOnly: CGRect? = nil) {
@@ -269,6 +326,139 @@ final class CaptureModel: ObservableObject {
     }
 }
 
+// MARK: - Cap-style design tokens
+
+/// Visual language modeled after the Cap screen recorder (cap.so):
+/// white card surfaces on a light canvas, capsule controls, circular
+/// icon buttons, and Cap's brand blue for primary actions.
+private enum CapStyle {
+    /// Cap's brand blue (#538EFF).
+    static let blue = Color(red: 83 / 255, green: 142 / 255, blue: 1)
+
+    private static func adaptive(_ light: NSColor, _ dark: NSColor) -> Color {
+        Color(nsColor: NSColor(name: nil, dynamicProvider: { appearance in
+            appearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua ? dark : light
+        }))
+    }
+
+    /// Pill/track fill (segmented control track, capsule buttons).
+    static let track = adaptive(NSColor(white: 0.93, alpha: 1), NSColor(white: 1, alpha: 0.1))
+    /// Card/content surfaces.
+    static let card = adaptive(.white, NSColor(white: 0.17, alpha: 1))
+    /// Canvas behind the content card.
+    static let canvas = adaptive(NSColor(white: 0.96, alpha: 1), NSColor(white: 0.12, alpha: 1))
+    /// Hairline borders.
+    static let border = adaptive(NSColor(white: 0, alpha: 0.08), NSColor(white: 1, alpha: 0.12))
+    /// Soft blue highlight for active tools (Cap's "On" pill).
+    static let blueTint = adaptive(
+        NSColor(red: 218 / 255, green: 233 / 255, blue: 1, alpha: 1),
+        NSColor(red: 83 / 255, green: 142 / 255, blue: 1, alpha: 0.28)
+    )
+}
+
+private struct CapPressableStyle: ButtonStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.label
+            .opacity(configuration.isPressed ? 0.7 : 1)
+            .scaleEffect(configuration.isPressed ? 0.96 : 1)
+    }
+}
+
+/// Sliding-pill segmented control (Cap's Screen/Window switcher).
+private struct CapModePicker: View {
+    @Binding var mode: CaptureModel.CaptureMode
+    @Namespace private var selection
+
+    var body: some View {
+        HStack(spacing: 2) {
+            item(.screenshot, title: "Screenshot")
+            item(.text, title: "Text")
+        }
+        .padding(2.5)
+        .background(Capsule().fill(CapStyle.track))
+    }
+
+    private func item(_ value: CaptureModel.CaptureMode, title: String) -> some View {
+        let isSelected = mode == value
+        return Button {
+            withAnimation(.spring(response: 0.28, dampingFraction: 0.85)) { mode = value }
+        } label: {
+            Text(title)
+                .font(.system(size: 12, weight: .medium))
+                .foregroundStyle(isSelected ? Color.primary : Color.secondary)
+                .padding(.horizontal, 13)
+                .padding(.vertical, 4.5)
+                .background {
+                    if isSelected {
+                        Capsule()
+                            .fill(CapStyle.card)
+                            .shadow(color: Color.black.opacity(0.14), radius: 1.5, y: 1)
+                            .matchedGeometryEffect(id: "mode", in: selection)
+                    }
+                }
+                .contentShape(Capsule())
+        }
+        .buttonStyle(CapPressableStyle())
+    }
+}
+
+/// Capsule button; primary renders in Cap blue.
+private struct CapCapsuleButton: View {
+    let title: String
+    let icon: String
+    var primary = false
+    var disabled = false
+    var help: String
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            Label(title, systemImage: icon)
+                .font(.system(size: 12, weight: .medium))
+                .foregroundStyle(primary ? Color.white : Color.primary.opacity(0.85))
+                .padding(.horizontal, 11)
+                .padding(.vertical, 5.5)
+                .background(Capsule().fill(primary ? CapStyle.blue : CapStyle.track))
+                .contentShape(Capsule())
+        }
+        .buttonStyle(CapPressableStyle())
+        .disabled(disabled)
+        .opacity(disabled ? 0.5 : 1)
+        .help(help)
+    }
+}
+
+/// Circular icon button with hover fill and a blue-tinted active state.
+private struct CapIconButton: View {
+    let icon: String
+    var active = false
+    var disabled = false
+    var help: String
+    var shortcut: KeyboardShortcut? = nil
+    let action: () -> Void
+    @State private var hovering = false
+
+    var body: some View {
+        Button(action: action) {
+            Image(systemName: icon)
+                .font(.system(size: 13, weight: .medium))
+                .foregroundStyle(active ? CapStyle.blue : Color.secondary)
+                .frame(width: 29, height: 29)
+                .background(Circle().fill(active ? CapStyle.blueTint : (hovering ? CapStyle.track : Color.clear)))
+                .contentShape(Circle())
+        }
+        .buttonStyle(CapPressableStyle())
+        .keyboardShortcut(shortcut)
+        .onHover { hovering = $0 }
+        .animation(.easeOut(duration: 0.12), value: hovering)
+        .disabled(disabled)
+        .opacity(disabled ? 0.4 : 1)
+        .help(help)
+    }
+}
+
+// MARK: - Result window
+
 struct ResultView: View {
     @ObservedObject var model: CaptureModel
     let onClose: () -> Void
@@ -276,163 +466,127 @@ struct ResultView: View {
     var body: some View {
         VStack(spacing: 0) {
             // Toolbar
-            HStack(spacing: 10) {
-                Picker("", selection: $model.mode) {
-                    Text("Screenshot").tag(CaptureModel.CaptureMode.screenshot)
-                    Text("Text").tag(CaptureModel.CaptureMode.text)
-                }
-                .pickerStyle(.segmented)
-                .fixedSize()
+            HStack(spacing: 6) {
+                CapModePicker(mode: $model.mode)
 
                 Spacer()
 
                 if model.hasSelection {
-                    Button {
-                        model.runOCRSelection()
-                    } label: {
-                        Label("OCR Selection", systemImage: "text.magnifyingglass")
-                    }
-                    .buttonStyle(.borderedProminent)
-                    .disabled(model.isOCRRunning)
-                    .help("Recognize text inside the selected region")
+                    CapCapsuleButton(
+                        title: "OCR Selection", icon: "text.magnifyingglass",
+                        primary: true, disabled: model.isOCRRunning,
+                        help: "Recognize text inside the selected region"
+                    ) { model.runOCRSelection() }
+
+                    CapCapsuleButton(
+                        title: "Crop", icon: "crop",
+                        help: "Crop the image to the selected region"
+                    ) { model.cropToSelection() }
                 }
 
-                Button {
-                    model.runOCR()
-                } label: {
-                    Label("Get All Text", systemImage: "text.viewfinder")
-                }
-                .buttonStyle(.bordered)
-                .disabled(model.isOCRRunning)
-                .help("Recognize all text in the screenshot")
+                CapCapsuleButton(
+                    title: "Get All Text", icon: "text.viewfinder",
+                    primary: !model.hasSelection, disabled: model.isOCRRunning,
+                    help: "Recognize all text in the screenshot"
+                ) { model.runOCR() }
 
-                Divider().frame(height: 18)
-
-                Button {
-                    model.isDrawing.toggle()
-                    if model.isDrawing { model.selection = nil }
-                } label: {
-                    Label("Draw", systemImage: model.isDrawing ? "pencil.tip.crop.circle.fill" : "pencil.tip.crop.circle")
+                CapIconButton(
+                    icon: model.tool == .draw ? "pencil.tip.crop.circle.fill" : "pencil.tip.crop.circle",
+                    active: model.tool == .draw,
+                    help: "Draw on the screenshot"
+                ) {
+                    model.tool = model.tool == .draw ? .select : .draw
+                    if model.tool != .select { model.selection = nil }
                 }
-                .buttonStyle(.bordered)
-                .foregroundStyle(model.isDrawing ? .primary : .secondary)
-                .help("Toggle drawing on the screenshot")
 
-                Button {
-                    model.copyImage()
-                } label: {
-                    Label("Copy", systemImage: "doc.on.doc")
+                CapIconButton(
+                    icon: model.tool == .redact ? "rectangle.fill.on.rectangle.fill" : "rectangle.dashed",
+                    active: model.tool == .redact,
+                    help: "Cover sensitive areas with black bars"
+                ) {
+                    model.tool = model.tool == .redact ? .select : .redact
+                    if model.tool != .select { model.selection = nil }
                 }
-                .buttonStyle(.bordered)
-                .help("Copy image to clipboard")
 
-                Button {
-                    model.savePNG()
-                } label: {
-                    Label("Save", systemImage: "square.and.arrow.down")
-                }
-                .buttonStyle(.bordered)
-                .help("Save screenshot as PNG");
-
-                Button {
-                    onClose()
-                } label: {
-                    Image(systemName: "xmark.circle.fill")
-                        .foregroundStyle(.secondary)
-                }
-                .buttonStyle(.plain)
-                .help("Close")
+                CapIconButton(icon: "doc.on.doc", help: "Copy image to clipboard") { model.copyImage() }
+                CapIconButton(icon: "square.and.arrow.down", help: "Save screenshot as PNG") { model.savePNG() }
+                CapIconButton(icon: "xmark", help: "Close") { onClose() }
             }
-            .padding(.horizontal, 14)
-            .padding(.vertical, 10)
+            .padding(.horizontal, 12)
+            .padding(.vertical, 9)
 
-            Divider()
-
-            // Draw toolbar (only when drawing)
-            if model.isDrawing {
+            // Tool options (only when a draw tool is active)
+            if model.tool != .select {
                 HStack(spacing: 14) {
-                    Label("Draw", systemImage: "pencil.tip")
+                    Label(model.tool == .redact ? "Redact" : "Draw", systemImage: model.tool == .redact ? "rectangle.fill" : "pencil.tip")
                         .font(.caption)
                         .foregroundStyle(.secondary)
 
-                    Divider().frame(height: 18)
+                    if model.tool == .draw {
+                        HStack(spacing: 6) {
+                            Image(systemName: "circle.fill").font(.system(size: 4))
+                            Image(systemName: "circle.fill").font(.system(size: 7))
+                            Image(systemName: "circle.fill").font(.system(size: 10))
+                        }
+                        .foregroundStyle(.secondary)
+                        Slider(value: $model.strokeWidth, in: 1...12, step: 0.5)
+                            .frame(width: 120)
+                            .tint(CapStyle.blue)
+                            .help("Stroke thickness")
 
-                    HStack(spacing: 6) {
-                        Image(systemName: "circle.fill").font(.system(size: 4))
-                        Image(systemName: "circle.fill").font(.system(size: 7))
-                        Image(systemName: "circle.fill").font(.system(size: 10))
+                        ColorPicker("", selection: Binding(
+                            get: { Color(nsColor: model.drawColor) },
+                            set: { model.drawColor = NSColor($0) }
+                        ), supportsOpacity: false)
+                        .labelsHidden()
+                        .frame(width: 28)
+                        .help("Drawing color")
+                    } else {
+                        Label("Drag to cover sensitive text", systemImage: "eye.slash")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
                     }
-                    .foregroundStyle(.secondary)
-                    Slider(value: $model.strokeWidth, in: 1...12, step: 0.5)
-                        .frame(width: 120)
-                        .help("Stroke thickness")
-
-                    Divider().frame(height: 18)
-
-                    ColorPicker("", selection: Binding(
-                        get: { Color(nsColor: model.drawColor) },
-                        set: { model.drawColor = NSColor($0) }
-                    ), supportsOpacity: false)
-                    .labelsHidden()
-                    .frame(width: 28)
-                    .help("Drawing color")
 
                     Spacer()
 
-                    Button {
-                        model.undoStroke()
-                    } label: {
-                        Label("Undo", systemImage: "arrow.uturn.backward")
-                    }
-                    .buttonStyle(.bordered)
-                    .controlSize(.small)
-                    .disabled(!model.canUndo)
-                    .keyboardShortcut("z", modifiers: .command)
-                    .help("Undo last stroke (⌘Z)")
+                    CapIconButton(
+                        icon: "arrow.uturn.backward", disabled: !model.canUndo,
+                        help: "Undo last stroke (⌘Z)",
+                        shortcut: KeyboardShortcut("z", modifiers: .command)
+                    ) { model.undoStroke() }
 
-                    Button {
-                        model.redoStroke()
-                    } label: {
-                        Label("Redo", systemImage: "arrow.uturn.forward")
-                    }
-                    .buttonStyle(.bordered)
-                    .controlSize(.small)
-                    .disabled(!model.canRedo)
-                    .keyboardShortcut("z", modifiers: [.command, .shift])
-                    .help("Redo stroke (⌘⇧Z)")
+                    CapIconButton(
+                        icon: "arrow.uturn.forward", disabled: !model.canRedo,
+                        help: "Redo stroke (⌘⇧Z)",
+                        shortcut: KeyboardShortcut("z", modifiers: [.command, .shift])
+                    ) { model.redoStroke() }
 
-                    Button {
-                        model.clearAnnotations()
-                    } label: {
-                        Label("Clear", systemImage: "eraser")
-                    }
-                    .buttonStyle(.bordered)
-                    .controlSize(.small)
-                    .disabled(model.strokes.isEmpty)
-                    .help("Remove all drawn annotations")
+                    CapIconButton(
+                        icon: "eraser", disabled: model.strokes.isEmpty,
+                        help: "Remove all drawn annotations"
+                    ) { model.clearAnnotations() }
                 }
-                .padding(.horizontal, 14)
-                .padding(.vertical, 8)
-                .background(.bar)
-
-                Divider()
+                .padding(.horizontal, 12)
+                .padding(.vertical, 6)
             }
 
             // Content
             if model.mode == .screenshot {
                 ScreenshotPane(model: model)
-                    .padding(12)
+                    .padding(10)
+                    .background(CapStyle.canvas)
             } else {
-                ZStack {
-                    ScrollView {
-                        Text(model.displayText)
-                            .font(.system(.body, design: .monospaced))
-                            .textSelection(.enabled)
-                            .frame(maxWidth: .infinity, alignment: .leading)
-                            .padding(12)
-                    }
+                ScrollView {
+                    Text(model.displayText)
+                        .font(.system(.body, design: .monospaced))
+                        .textSelection(.enabled)
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .padding(14)
                 }
-                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                .background(CapStyle.card, in: RoundedRectangle(cornerRadius: 10))
+                .overlay(RoundedRectangle(cornerRadius: 10).strokeBorder(CapStyle.border, lineWidth: 1))
+                .padding(10)
+                .background(CapStyle.canvas)
             }
 
             // Status bar
@@ -442,7 +596,7 @@ struct ResultView: View {
                         .controlSize(.small)
                 }
                 Text(model.statusMessage ?? (model.mode == .screenshot
-                    ? (model.hasSelection ? "Region selected — click OCR Selection." : "Drag to select a region, or Get All Text.")
+                    ? (model.hasSelection ? "Region selected — OCR it or Crop." : "Drag to select a region, or Get All Text.")
                     : "Selectable text"))
                     .font(.caption)
                     .foregroundStyle(.secondary)
@@ -451,20 +605,17 @@ struct ResultView: View {
                 Spacer()
 
                 if model.mode == .text, model.extractedText != nil {
-                    Button {
-                        model.copyText()
-                    } label: {
-                        Label("Copy Text", systemImage: "doc.on.doc")
-                    }
-                    .buttonStyle(.bordered)
-                    .controlSize(.small)
+                    CapCapsuleButton(
+                        title: "Copy Text", icon: "doc.on.doc",
+                        help: "Copy recognized text to the clipboard"
+                    ) { model.copyText() }
                 }
             }
-            .padding(.horizontal, 14)
-            .padding(.vertical, 8)
-            .background(.bar)
+            .padding(.horizontal, 12)
+            .padding(.vertical, 7)
         }
-        .frame(minWidth: 520, minHeight: 420)
+        .background(Color(nsColor: .windowBackgroundColor))
+        .frame(minWidth: 600, minHeight: 420)
     }
 }
 
@@ -502,27 +653,51 @@ struct ScreenshotPane: View {
     var body: some View {
         GeometryReader { geo in
             let (scale, drawSize, origin) = geometry(for: geo)
+            let cardRect = CGRect(origin: origin, size: drawSize)
+            let cardClip = RoundedRectangle(cornerRadius: 10).path(in: cardRect)
 
             ZStack {
+                // Card behind the image
+                RoundedRectangle(cornerRadius: 10)
+                    .fill(CapStyle.card)
+                    .shadow(color: Color.black.opacity(0.08), radius: 8, y: 2)
+                    .frame(width: drawSize.width, height: drawSize.height)
+                    .position(x: cardRect.midX, y: cardRect.midY)
+
                 Image(nsImage: NSImage(cgImage: model.image, size: .zero))
                     .resizable()
                     .interpolation(imageSize.width >= geo.size.width ? .high : .none)
                     .aspectRatio(contentMode: .fit)
                     .frame(width: drawSize.width, height: drawSize.height)
-                    .position(x: origin.x + drawSize.width / 2, y: origin.y + drawSize.height / 2)
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+                    .position(x: cardRect.midX, y: cardRect.midY)
 
                 // Completed strokes
                 Canvas { context, _ in
                     for stroke in model.strokes {
                         guard stroke.points.count > 1 else { continue }
-                        var path = Path()
-                        path.move(to: CGPoint(x: origin.x + stroke.points[0].x * scale, y: origin.y + stroke.points[0].y * scale))
-                        for point in stroke.points.dropFirst() {
-                            path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
+                        if stroke.isRedaction {
+                            let xs = stroke.points.map { $0.x }
+                            let ys = stroke.points.map { $0.y }
+                            let bar = CGRect(
+                                x: origin.x + (xs.min()! - 2) * scale,
+                                y: origin.y + (ys.min()! - 2) * scale,
+                                width: ((xs.max()! - xs.min()!) + 4) * scale,
+                                height: (max(stroke.width, ys.max()! - ys.min()!) + 4) * scale
+                            )
+                            context.fill(Path(bar), with: .color(.black))
+                        } else {
+                            var path = Path()
+                            path.move(to: CGPoint(x: origin.x + stroke.points[0].x * scale, y: origin.y + stroke.points[0].y * scale))
+                            for point in stroke.points.dropFirst() {
+                                path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
+                            }
+                            // stroke.width is in image pixels; scale to view points
+                            context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width * scale)
                         }
-                        context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width)
                     }
                 }
+                .clipShape(cardClip)
                 .allowsHitTesting(false)
 
                 // In-progress stroke
@@ -537,10 +712,18 @@ struct ScreenshotPane: View {
                         }
                         context.stroke(path, with: .color(Color(nsColor: model.drawColor)), lineWidth: model.strokeWidth)
                     }
+                    .clipShape(cardClip)
                     .allowsHitTesting(false)
                 }
 
-                if !model.isDrawing, let sel = model.selection {
+                // Card hairline border
+                RoundedRectangle(cornerRadius: 10)
+                    .strokeBorder(CapStyle.border, lineWidth: 1)
+                    .frame(width: drawSize.width, height: drawSize.height)
+                    .position(x: cardRect.midX, y: cardRect.midY)
+                    .allowsHitTesting(false)
+
+                if model.tool == .select, let sel = model.selection {
                     let viewRect = CGRect(
                         x: origin.x + sel.minX * scale,
                         y: origin.y + sel.minY * scale,
@@ -548,8 +731,8 @@ struct ScreenshotPane: View {
                         height: sel.height * scale
                     )
                     Rectangle()
-                        .fill(Color.accentColor.opacity(0.15))
-                        .border(Color.accentColor, width: 1.5)
+                        .fill(CapStyle.blue.opacity(0.15))
+                        .border(CapStyle.blue, width: 1.5)
                         .frame(width: viewRect.width, height: viewRect.height)
                         .position(x: viewRect.midX, y: viewRect.midY)
                         .allowsHitTesting(false)
@@ -559,7 +742,7 @@ struct ScreenshotPane: View {
             .gesture(
                 DragGesture(minimumDistance: 0)
                     .onChanged { value in
-                        if model.isDrawing {
+                        if model.tool != .select {
                             let p = toImagePoint(value.location, scale: scale, origin: origin)
                             let imgRect = CGRect(origin: .zero, size: imageSize)
                             if imgRect.contains(p) {
@@ -578,9 +761,9 @@ struct ScreenshotPane: View {
                         }
                     }
                     .onEnded { _ in
-                        if model.isDrawing {
+                        if model.tool != .select {
                             if currentStroke.count > 1 {
-                                model.addStroke(currentStroke)
+                                model.addStroke(currentStroke, widthPx: model.strokeWidth / max(scale, 0.01))
                             }
                             currentStroke = []
                         } else {

Sources/Kapture/ScreenRecorder.swift

@@ -0,0 +1,203 @@
+import AppKit
+import AVFoundation
+import CoreMedia
+import ScreenCaptureKit
+
+/// Records a screen region (or a single window) to an H.264 .mov via
+/// SCStream -> AVAssetWriter. Works on macOS 13+ (no SCScreenshotManager).
+///
+/// Video-only for now: the audio path is wired behind `includeAudio`
+/// (off) — enabling sound later means setting the flag to true, which
+/// turns on `capturesAudio`, adds an AAC track, and starts appending
+/// audio sample buffers. That path is untested until enabled.
+final class ScreenRecorder: NSObject, SCStreamOutput, SCStreamDelegate {
+    /// Future: also record system audio into the .mov.
+    var includeAudio = false
+
+    private let queue = DispatchQueue(label: "dev.tzgyn.kapture.rec")
+    private var stream: SCStream?
+    private var writer: AVAssetWriter?
+    private var videoInput: AVAssetWriterInput?
+    private var audioInput: AVAssetWriterInput?
+    private var sessionStarted = false
+    private var outputURL: URL?
+
+    /// `region` is in AppKit global points. When `windowID` is given the
+    /// stream records that window directly (and follows it if it moves);
+    /// otherwise it records `region` via a display filter + sourceRect.
+    func start(region: NSRect, windowID: CGWindowID?, excludingWindowIDs: [Int], completion: @escaping (Bool) -> Void) {
+        Task {
+            do {
+                try await prepare(region: region, windowID: windowID, excludingWindowIDs: excludingWindowIDs)
+                completion(true)
+            } catch {
+                CaptureController.log("rec: start failed: \(error.localizedDescription)")
+                completion(false)
+            }
+        }
+    }
+
+    private func prepare(region: NSRect, windowID: CGWindowID?, excludingWindowIDs: [Int]) async throws {
+        let content = try await SCShareableContent.current
+
+        let excludedSet = Set(excludingWindowIDs.map { CGWindowID($0) })
+        let excluded = content.windows.filter { excludedSet.contains($0.windowID) }
+
+        let config = SCStreamConfiguration()
+        let filter: SCContentFilter
+        let pixelWidth: Int
+        let pixelHeight: Int
+
+        let regionCentre = NSPoint(x: region.midX, y: region.midY)
+        let screen = NSScreen.screens.first(where: { $0.frame.contains(regionCentre) }) ?? NSScreen.screens.first
+        let scale = screen?.backingScaleFactor ?? 2
+
+        if let windowID, let scWindow = content.windows.first(where: { $0.windowID == windowID }) {
+            filter = SCContentFilter(desktopIndependentWindow: scWindow)
+            pixelWidth = max(2, Int(scWindow.frame.width * scale) / 2 * 2)
+            pixelHeight = max(2, Int(scWindow.frame.height * scale) / 2 * 2)
+            CaptureController.log("rec: window id=\(windowID) \(pixelWidth)x\(pixelHeight)")
+        } else {
+            guard let screen else {
+                throw NSError(domain: "dev.tzgyn.kapture", code: 1, userInfo: [NSLocalizedDescriptionKey: "No screen for region"])
+            }
+            let cgID = (screen.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0
+            guard let display = content.displays.first(where: { $0.displayID == cgID }) ?? content.displays.first else {
+                throw NSError(domain: "dev.tzgyn.kapture", code: 2, userInfo: [NSLocalizedDescriptionKey: "No display for region"])
+            }
+            filter = SCContentFilter(display: display, excludingWindows: excluded)
+            // sourceRect is display-local POINTS with a TOP-LEFT origin
+            // (same mapping cropFrozen uses for the frozen snapshots).
+            let local = CGRect(
+                x: region.minX - screen.frame.minX,
+                y: screen.frame.maxY - region.maxY,
+                width: region.width,
+                height: region.height
+            ).intersection(CGRect(x: 0, y: 0, width: display.frame.width, height: display.frame.height))
+            guard local.width >= 2, local.height >= 2 else {
+                throw NSError(domain: "dev.tzgyn.kapture", code: 3, userInfo: [NSLocalizedDescriptionKey: "Region outside display"])
+            }
+            config.sourceRect = local
+            pixelWidth = max(2, Int(local.width * scale) / 2 * 2)
+            pixelHeight = max(2, Int(local.height * scale) / 2 * 2)
+            CaptureController.log("rec: region \(region) sourceRect=\(local) \(pixelWidth)x\(pixelHeight)")
+        }
+
+        config.width = pixelWidth
+        config.height = pixelHeight
+        config.minimumFrameInterval = CMTime(value: 1, timescale: 60)
+        config.pixelFormat = kCVPixelFormatType_32BGRA
+        // Recordings SHOULD include the pointer (unlike stills).
+        config.showsCursor = true
+        config.queueDepth = 6
+        config.capturesAudio = includeAudio
+
+        let movies = FileManager.default.urls(for: .moviesDirectory, in: .userDomainMask).first
+            ?? URL(fileURLWithPath: NSHomeDirectory())
+        let url = movies.appendingPathComponent("Kapture-\(Self.timestamp()).mov")
+        let writer = try AVAssetWriter(url: url, fileType: .mov)
+
+        let videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: [
+            AVVideoCodecKey: AVVideoCodecType.h264,
+            AVVideoWidthKey: pixelWidth,
+            AVVideoHeightKey: pixelHeight,
+        ])
+        videoInput.expectsMediaDataInRealTime = true
+        writer.add(videoInput)
+
+        var audioInput: AVAssetWriterInput?
+        if includeAudio {
+            let input = AVAssetWriterInput(mediaType: .audio, outputSettings: [
+                AVFormatIDKey: kAudioFormatMPEG4AAC,
+                AVSampleRateKey: 48000,
+                AVNumberOfChannelsKey: 2,
+            ])
+            input.expectsMediaDataInRealTime = true
+            writer.add(input)
+            audioInput = input
+        }
+
+        guard writer.startWriting() else {
+            throw writer.error ?? NSError(domain: "dev.tzgyn.kapture", code: 4, userInfo: [NSLocalizedDescriptionKey: "AVAssetWriter failed to start"])
+        }
+
+        let stream = SCStream(filter: filter, configuration: config, delegate: self)
+        try stream.addStreamOutput(self, type: .screen, sampleHandlerQueue: queue)
+        if includeAudio {
+            try stream.addStreamOutput(self, type: .audio, sampleHandlerQueue: queue)
+        }
+        try await stream.startCapture()
+
+        self.stream = stream
+        self.writer = writer
+        self.videoInput = videoInput
+        self.audioInput = audioInput
+        self.outputURL = url
+        CaptureController.log("rec: started -> \(url.lastPathComponent)")
+    }
+
+    /// Stops the stream and finalizes the file. Completion gets the URL on
+    /// success (called on an internal queue — hop to main for UI).
+    func stop(completion: @escaping (URL?) -> Void) {
+        Task {
+            try? await stream?.stopCapture()
+            stream = nil
+            queue.async {
+                guard let writer = self.writer else {
+                    completion(nil)
+                    return
+                }
+                self.videoInput?.markAsFinished()
+                self.audioInput?.markAsFinished()
+                let url = self.outputURL
+                self.writer = nil
+                self.videoInput = nil
+                self.audioInput = nil
+                self.sessionStarted = false
+                writer.finishWriting {
+                    CaptureController.log("rec: finished status=\(writer.status.rawValue)")
+                    completion(writer.status == .completed ? url : nil)
+                }
+            }
+        }
+    }
+
+    // MARK: SCStreamOutput (called on `queue`)
+
+    func stream(_ stream: SCStream, didOutputSampleBuffer sampleBuffer: CMSampleBuffer, of type: SCStreamOutputType) {
+        guard CMSampleBufferDataIsReady(sampleBuffer), let writer, let videoInput else { return }
+        switch type {
+        case .screen:
+            // Skip incomplete frames (macOS 13.1+ exposes a frame status).
+            if #available(macOS 13.1, *) {
+                guard let attachments = (CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, createIfNecessary: false) as? [NSDictionary])?.first,
+                      let dict = attachments as? [String: Any],
+                      let statusRaw = dict[SCStreamFrameInfo.status.rawValue] as? Int,
+                      SCFrameStatus(rawValue: statusRaw) == .complete else { return }
+            }
+            guard videoInput.isReadyForMoreMediaData else { return }
+            if !sessionStarted {
+                sessionStarted = true
+                writer.startSession(atSourceTime: CMSampleBufferGetPresentationTimeStamp(sampleBuffer))
+            }
+            videoInput.append(sampleBuffer)
+        case .audio:
+            guard includeAudio, sessionStarted, let audioInput, audioInput.isReadyForMoreMediaData else { return }
+            audioInput.append(sampleBuffer)
+        default:
+            break
+        }
+    }
+
+    // MARK: SCStreamDelegate
+
+    func stream(_ stream: SCStream, didStopWithError error: Error) {
+        CaptureController.log("rec: stream stopped with error: \(error.localizedDescription)")
+    }
+
+    private static func timestamp() -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd-HHmmss"
+        return formatter.string(from: Date())
+    }
+}

build-app.sh

@@ -108,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.5.0</string>
+    <string>1.11.0</string>
     <key>CFBundleVersion</key>
-    <string>50</string>
+    <string>110</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>