Fix captures on displays below the main screen

ScreenCaptureKit uses a flipped Y axis relative to AppKit NSScreen frames,
so selections on a display below the main screen produced out-of-bounds
crop rects and "Capture failed". Convert the selection into SCDisplay space
using the matching NSScreen's top edge before cropping.

💘 Generated with Crush

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

.gitignore

@@ -5,6 +5,9 @@
 # App bundle (build artifact, regenerate with ./build-app.sh)
 Kapture.app/
 
+# Secrets
+*.p8
+
 # macOS
 .DS_Store
 

AGENTS.md

@@ -0,0 +1,112 @@
+# AGENTS.md
+
+Kapture is a native macOS menu-bar screenshot + OCR app written in Swift/SwiftUI.
+Single executable SwiftPM package, no external dependencies (all Apple frameworks).
+
+## Architecture
+
+Control flow for the main path: menu bar → hotkey → overlay → capture → result window → OCR.
+
+- `Sources/Kapture/App.swift` — `@main` entry. `MenuBarExtra` menu, `AppDelegate`
+  (wires hotkey → `CaptureController.begin()`; handles `--test-ocr`), `PermissionManager`
+  (wraps `CGPreflightScreenCaptureAccess` / `CGRequestScreenCaptureAccess`).
+- `Sources/Kapture/HotkeyManager.swift` — Carbon `RegisterEventHotKey`, hardcoded
+  ⌘⇧S (`kVK_ANSI_S`, `cmdKey | shiftKey`), signature `0x4B505452`.
+- `Sources/Kapture/CaptureController.swift` — selection flow. Creates one borderless
+  `NSPanel` overlay per screen, then captures via `ScreenCapture` and hands the image
+  to `ResultWindow`. Coordination happens in `begin()`/`finishSelection()`/`cancelSelection()`.
+- `Sources/Kapture/ScreenCapture` (same file) — macOS 14+: ScreenCaptureKit
+  `SCScreenshotManager` + manual pixel-space crop (`display.width / display.frame.width`
+  scale); macOS 13: `CGWindowListCreateImage` fallback.
+- `Sources/Kapture/OverlayView.swift` — `NSPanel` + `NSView` drawing overlay; mouse-driven
+  rect selection (min 2×2 pt), Escape (keyCode 53) cancels; selection committed via
+  `window.convertToScreen` (screen coordinates).
+- `Sources/Kapture/OCRService.swift` — Vision `VNRecognizeTextRequest`, `.accurate`
+  level, languages `["en-US", "zh-Hans", "zh-Hant", "ja-JP", "ko-KR"]`. Custom
+  line-order sort: observations sorted top→bottom by `boundingBox.midY` (tolerance
+  `0.02`), then left→right. Runs on a private serial `DispatchQueue`
+  (`dev.tzgyn.kapture.ocr`), completes on that queue — callers must hop back to main.
+- `Sources/Kapture/ResultWindow.swift` — `ResultWindow.show(image:)` (single shared
+  floating window, closes previous), `CaptureModel` (ObservableObject, `@Published`
+  `mode` = screenshot/text), `ResultView` (SwiftUI, Screenshot/Text tabs, Get Text /
+  Save PNG / Copy Text).
+
+Singletons everywhere: `HotkeyManager.shared`, `CaptureController.shared`,
+`ScreenCapture.shared`, `OCRService.shared`, `ResultWindow.shared`.
+
+Note: packaging references `dev.tzgyn.kapture` as the bundle identifier — match this
+in any new code (queue labels, TCC/plist references).
+
+## Commands
+
+```bash
+swift build                  # debug build (also: swift run Kapture)
+swift build -c release       # release build (what build-app.sh uses)
+swift run Kapture            # dev run from terminal (app appears in Dock)
+swift run Kapture --test-ocr # OCR smoke test: renders text, OCRs it, prints PASS/FAIL, exit 0/1
+./build-app.sh               # release build + Kapture.app bundle + icon + ad-hoc codesign
+./release.sh <version>       # e.g. ./release.sh 1.0.1: builds app, zips to dist/Kapture.zip, prints sha256
+scripts/make-icon.sh         # regenerates Kapture.app/Contents/Resources/Icon.icns from scripts/gen-icon.swift
+```
+
+There is no test target and no linter/formatter configured. Verification = build +
+`--test-ocr`.
+
+## Bundle build & signing
+
+`build-app.sh` does: release build → handwritten `Info.plist` (NOT generated from
+`Package.swift`) → `make-icon.sh` → `codesign` with self-signed identity `kapture-dev`
+stored in a dedicated keychain at `~/.config/kapture/signing.keychain-db` (not the
+login keychain). Honest bugs to keep in mind:
+
+- Uses `security create-keychain`/`unlock-keychain` with a hardcoded password
+  (`kapture-dev`) — if the cert creation fails midway, the keychain may be left in an
+  undefined state; the script is mostly idempotent but re-run it before assuming failure.
+- The self-signed cert is created with Homebrew OpenSSL (`/opt/homebrew/bin/openssl`,
+  falls back to `/usr/local/bin/openssl`, then system `openssl`) and imported as a
+  pkcs12 (`-export -legacy`). The legacy flag is important — modern OpenSSL defaults
+  to formats the macOS `security` tool rejects.
+- `LSUIElement` = true → no Dock icon. Info.plist also hardcodes
+  `CFBundleShortVersionString` 1.0 / `CFBundleVersion` 1 — bump here for releases,
+  and match it in `release.sh` args.
+
+macOS may require re-granting Screen Recording permission when the binary identity
+changes (TCC tracks the binary, not the source).
+
+## Release process
+
+1. `./release.sh <version>` — builds, zips `Kapture.app` to `dist/Kapture.zip`,
+   prints its sha256 (that's all it does, it does not tag or upload).
+2. Tag `git tag v<version> && git push origin v<version>` and attach the zip to a
+   GitHub release manually (the old `.github/workflows/release.yml` was removed;
+   `release.sh` output still says the workflow will upload the zip, which is stale).
+3. The Homebrew cask lives in `TZGyn/homebrew-tap` — bump `version` and `sha256`
+   there for each release.
+
+Icon note: the cask references the `Icon.icns` built into the app bundle, so no
+separate icon release step needed.
+
+## Gotchas
+
+- Coordinate spaces differ: overlay selections are in global screen points
+  (via `convertToScreen`), ScreenCaptureKit images are in pixels and the crop must
+  scale by `display.width / display.frame.width`. Don't mix them.
+- Starting on macOS 13 vs 14 changes the capture path: 13 uses the `CGWindowListCreateImage`
+  fallback, which only handles the primary screen (`frame.origin == .zero`) and
+  needs explicit Y-flip (`primary.frame.height - rect.maxY`). Get selection rect
+  handling wrong on one path and you break only one OS version — test on both.
+- When selection overlays are active for more than one screen macOS may also be
+  capturing the overlay panels themselves while the selection is running; the overlay
+  windows' `windowNumber` IDs are collected in `begin()` and excluded via
+  `SCContentFilter(excludingWindows:)` when capturing. If you add any new window that
+  shows during overlay/selection, add it to the exclusion set.
+- The OCR completion runs on a background queue — never touch `CaptureModel`/UI from
+  it; `runOCR` hops to `@MainActor` via `Task { @MainActor in ... }`.
+- `--test-ocr` is processed in `AppDelegate.applicationDidFinishLaunching` and must
+  `exit()` with 0/1 inside the completion; the `RunLoop.main.run()` after is what keeps
+  the process alive until the async OCR finishes. If OCR returns empty text it
+  doesn't crash — just prints FAIL.
+- No `@MainActor` annotations on AppDelegate / HotkeyManager; keep new code on main
+  thread for AppKit calls.
+- `.gitignore` covers `.build/`, `Kapture.app/`, `dist/` — build artifacts should
+  never be committed.

README.md

@@ -13,6 +13,7 @@ No network calls, no API keys — everything runs locally.
 
 - Global hotkey **⌘⇧S** works from any app
 - Region selection overlay (all screens, Escape cancels)
+- **Launch at Login** toggle in the menu bar
 - The screenshot appears in a window (Screenshot / Text tabs) instead of being
   instantly OCR'd
 - **Get Text** button runs on-device OCR (English, Chinese simplified/traditional,
@@ -21,6 +22,24 @@ No network calls, no API keys — everything runs locally.
 - Open an existing image file (or drag) via the menu bar icon
 - Menu bar icon with permission status
 
+## Install with Homebrew
+
+```bash
+brew tap TZGyn/tap
+brew trust TZGyn/tap          # Homebrew 6+ requires trusting third-party taps
+brew install --cask kapture
+```
+
+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)
+repository — bump the `version` and `sha256` there for each release.
+
+Note: builds are ad-hoc signed (no App Store / Developer ID notarization), so
+first launch of a new version may trigger a Gatekeeper warning — users can
+right-click → Open, or the warning goes away when the binary identity matches a
+previously-granted permission.
+
 ## Build & run
 
 ```bash

Sources/Kapture/App.swift

@@ -1,6 +1,7 @@
 import SwiftUI
 import AppKit
 import CoreGraphics
+import ServiceManagement
 
 @main
 struct KaptureApp: App {
@@ -47,6 +48,26 @@ struct MenuView: View {
 
         Divider()
 
+        Button("Copy Diagnostics") {
+            let diag = CaptureController.shared.diagnostics()
+            let pasteboard = NSPasteboard.general
+            pasteboard.clearContents()
+            pasteboard.setString(diag, forType: .string)
+        }
+
+        Button(LoginItem.isEnabled ? "Disable Launch at Login" : "Launch at Login") {
+            if !LoginItem.toggle() {
+                let alert = NSAlert()
+                alert.messageText = "Could not update Launch at Login"
+                alert.informativeText = "Launch at Login requires a signed app bundle in /Applications. It is not available when running via `swift run`."
+                alert.alertStyle = .warning
+                alert.addButton(withTitle: "OK")
+                alert.runModal()
+            }
+        }
+
+        Divider()
+
         Button("Quit Kapture") { NSApp.terminate(nil) }
             .keyboardShortcut("q")
     }
@@ -60,6 +81,26 @@ enum PermissionManager {
     }
 }
 
+enum LoginItem {
+    static var isEnabled: Bool {
+        SMAppService.mainApp.status == .enabled
+    }
+
+    static func toggle() -> Bool {
+        let service = SMAppService.mainApp
+        do {
+            if service.status == .enabled {
+                try service.unregister()
+            } else {
+                try service.register()
+            }
+            return true
+        } catch {
+            return false
+        }
+    }
+}
+
 func runOCRSelfTest() {
     let text = "Kapture OCR test 1234, hello world"
     let size = NSSize(width: 1600, height: 220)

Sources/Kapture/CaptureController.swift

@@ -10,6 +10,38 @@ final class CaptureController: NSObject {
     private var previousApp: NSRunningApplication?
     private var overlayIDs: [Int] = []
 
+    /// Diagnostic snapshot for "Copy Diagnostics" menu item.
+    func diagnostics() -> String {
+        var lines: [String] = []
+        lines.append("Kapture diagnostics")
+        for (i, s) in NSScreen.screens.enumerated() {
+            let scale = s.backingScaleFactor
+            let cgID = (s.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0
+            lines.append("screen[\(i)]: frame=\(s.frame) scale=\(scale) backingSize=\(s.frame.width*scale)x\(s.frame.height*scale) cgID=\(cgID)")
+        }
+        if #available(macOS 14.0, *) {
+            Task {
+                if let content = try? await SCShareableContent.current {
+                    for (i, d) in content.displays.enumerated() {
+                        lines.append("SCDisplay[\(i)]: frame=\(d.frame) width=\(d.width)x\(d.height) id=\(d.displayID)")
+                    }
+                } else {
+                    lines.append("SCShareableContent: unavailable (no Screen Recording permission?)")
+                }
+                let text = lines.joined(separator: "\n")
+                let pb = NSPasteboard.general
+                pb.clearContents()
+                pb.setString(text, forType: .string)
+            }
+        } else {
+            let text = lines.joined(separator: "\n")
+            let pb = NSPasteboard.general
+            pb.clearContents()
+            pb.setString(text, forType: .string)
+        }
+        return lines.joined(separator: "\n")
+    }
+
     func begin() {
         guard !isSelecting else { return }
         guard PermissionManager.isGranted else {
@@ -85,29 +117,31 @@ final class ScreenCapture {
     private init() {}
 
     @available(macOS 14.0, *)
-    private func crop(_ image: CGImage, to rect: NSRect, display: SCDisplay) -> CGImage? {
-        let scaleX = CGFloat(display.width) / display.frame.width
-        let scaleY = CGFloat(display.height) / display.frame.height
-        let cgRect = CGRect(
-            x: rect.minX,
-            y: rect.minY,
-            width: rect.width,
-            height: rect.height
-        )
+    private func crop(_ image: CGImage, to cgRect: CGRect, display: SCDisplay) -> CGImage? {
+        // cgRect is already in SCDisplay space (Y flipped relative to AppKit).
+        // Derive the pixel scale from the image we actually got, relative to
+        // the display's point frame.
+        let scaleX = CGFloat(image.width) / display.frame.width
+        let scaleY = CGFloat(image.height) / display.frame.height
+        guard scaleX > 0, scaleY > 0 else { return nil }
         let pxRect = CGRect(
             x: (cgRect.minX - display.frame.minX) * scaleX,
             y: (cgRect.minY - display.frame.minY) * scaleY,
             width: cgRect.width * scaleX,
             height: cgRect.height * scaleY
         )
+        // Guard against negative offsets when the selection reaches beyond the
+        // display's frame (e.g. secondary monitor coordinate quirks).
+        let safeRect = pxRect.intersection(CGRect(x: 0, y: 0, width: CGFloat(image.width), height: CGFloat(image.height)))
+        guard safeRect.width >= 1, safeRect.height >= 1 else { return nil }
         guard let cropCtx = CGContext(
-            data: nil, width: Int(pxRect.width), height: Int(pxRect.height),
+            data: nil, width: Int(safeRect.width), height: Int(safeRect.height),
             bitsPerComponent: 8, bytesPerRow: 0,
             space: CGColorSpaceCreateDeviceRGB(),
             bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
         ) else { return nil }
         cropCtx.interpolationQuality = .high
-        cropCtx.draw(image, in: CGRect(x: -pxRect.minX, y: -pxRect.minY, width: CGFloat(image.width), height: CGFloat(image.height)))
+        cropCtx.draw(image, in: CGRect(x: -safeRect.minX, y: -safeRect.minY, width: CGFloat(image.width), height: CGFloat(image.height)))
         return cropCtx.makeImage()
     }
 
@@ -133,15 +167,34 @@ final class ScreenCapture {
                 let excluded = content.windows.filter { excludedSet.contains($0.windowID) }
                 let filter = SCContentFilter(display: display, excludingWindows: excluded)
                 let config = SCStreamConfiguration()
-                config.width = Int(display.width)
-                config.height = Int(display.height)
+                // SCDisplay.width/height are in POINTS; SCStreamConfiguration
+                // width/height are output PIXELS. Multiply by the backing scale
+                // of the screen containing the selection so retina displays are
+                // captured at full resolution and 1x displays stay 1x.
+                guard let screen = NSScreen.screens.first(where: { $0.frame.contains(NSPoint(x: rect.midX, y: rect.midY)) }) else {
+                    completion(nil)
+                    return
+                }
+                let backingScale = screen.backingScaleFactor
+                config.width = Int(CGFloat(display.width) * backingScale)
+                config.height = Int(CGFloat(display.height) * backingScale)
                 config.showsCursor = true
 
+                // ScreenCaptureKit's Y axis is flipped relative to AppKit
+                // NSScreen frames. Convert the selection into SCDisplay space
+                // using the matching NSScreen's top edge, then crop there.
+                let scRect = CGRect(
+                    x: rect.minX,
+                    y: screen.frame.maxY - rect.maxY + display.frame.minY,
+                    width: rect.width,
+                    height: rect.height
+                )
+
                 guard let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config) else {
                     completion(nil)
                     return
                 }
-                completion(self.crop(image, to: rect, display: display))
+                completion(self.crop(image, to: scRect, display: display))
             }
         } else {
             guard let primary = NSScreen.screens.first(where: { $0.frame.origin == .zero }) ?? NSScreen.screens.first else {

Sources/Kapture/ResultWindow.swift

@@ -5,24 +5,44 @@ import UniformTypeIdentifiers
 final class ResultWindow {
     static let shared = ResultWindow()
 
-    private var window: NSWindow?
+    private var windows: [NSWindow] = []
+    private var nextOrigin = NSPoint(x: 60, y: 60)
+    private var openCount = 0
 
     @MainActor
     func show(image: CGImage) {
-        window?.close()
         let model = CaptureModel(image: image)
-        let hosting = NSHostingController(rootView: ResultView(model: model) { [weak self] in
-            self?.window?.close()
+        let w = NSWindow()
+        w.contentViewController = NSHostingController(rootView: ResultView(model: model) {
+            w.close()
         })
-        let w = NSWindow(contentViewController: hosting)
-        w.title = "Kapture — Screenshot"
+        w.title = "Kapture — Screenshot" + (openCount > 0 ? " \(openCount + 1)" : "")
         w.level = .floating
         w.styleMask = [.titled, .closable, .resizable]
         w.setContentSize(NSSize(width: 694, height: 520))
         w.isReleasedWhenClosed = false
-        w.center()
+        w.setFrameOrigin(nextOrigin)
         w.makeKeyAndOrderFront(nil)
-        window = w
+
+        windows.append(w)
+        openCount += 1
+        nextOrigin = NSPoint(x: nextOrigin.x + 28, y: nextOrigin.y - 28)
+
+        windowCleanup(for: w)
+    }
+
+    private func windowCleanup(for window: NSWindow) {
+        NotificationCenter.default.addObserver(
+            forName: NSWindow.willCloseNotification,
+            object: window,
+            queue: .main
+        ) { [weak self] _ in
+            Task { @MainActor in
+                guard let self else { return }
+                self.windows.removeAll { $0 === window }
+                self.openCount = max(0, self.openCount - 1)
+            }
+        }
     }
 
     @MainActor
@@ -115,6 +135,13 @@ final class CaptureModel: ObservableObject {
         statusMessage = "Copied to clipboard."
     }
 
+    func copyImage() {
+        let pasteboard = NSPasteboard.general
+        pasteboard.clearContents()
+        pasteboard.writeObjects([NSImage(cgImage: image, size: .zero)])
+        statusMessage = "Image copied to clipboard."
+    }
+
     func savePNG() {
         let panel = NSSavePanel()
         panel.allowedContentTypes = [.png]
@@ -156,6 +183,7 @@ struct ResultView: View {
                 .pickerStyle(.segmented)
                 .fixedSize()
                 Spacer()
+                Button("Copy Image") { model.copyImage() }
                 Button("Save PNG…") { model.savePNG() }
                 Button("Get Text") { model.runOCR() }
                     .disabled(model.isOCRRunning || model.extractedText != nil)
@@ -165,9 +193,14 @@ struct ResultView: View {
             .padding(.top, 10)
 
             if model.mode == .screenshot {
+                GeometryReader { geo in
+                    let imageWidth = CGFloat(model.image.width)
                     Image(nsImage: NSImage(cgImage: model.image, size: .zero))
                         .resizable()
+                        // Downscale with smoothing (AA); upscale keeps pixels crisp.
+                        .interpolation(imageWidth >= geo.size.width ? .high : .none)
                         .aspectRatio(contentMode: .fit)
+                }
                 .border(Color.secondary.opacity(0.4))
                 .padding(.horizontal, 12)
             } else {

build-app.sh

@@ -12,6 +12,28 @@ KEYCHAIN="$SIGN_DIR/signing.keychain-db"
 KCHAIN_PASS="kapture-dev"
 mkdir -p "$SIGN_DIR"
 
+# Prefer a Developer ID Application identity (login keychain) so the app gets
+# clean Gatekeeper behavior; fall back to the self-signed "kapture-dev" identity.
+# Resolve by keychain path to avoid ambiguous matches.
+DEV_IDENT=""
+if command -v security >/dev/null 2>&1; then
+    DEV_IDENT=$(security find-identity -v -p codesigning 2>/dev/null | awk '/Developer ID Application:/ { print $2; exit }')
+fi
+SIGN_KEYCHAIN=""
+if [ -n "$DEV_IDENT" ]; then
+    CERT="$DEV_IDENT"
+    echo "Using Developer ID identity: $CERT"
+    # Ensure the login keychain holding the Dev ID is unlocked & accessible.
+    security unlock-keychain "$HOME/Library/Keychains/login.keychain-db" 2>/dev/null || true
+    security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "" "$HOME/Library/Keychains/login.keychain-db" >/dev/null 2>&1 || true
+    SIGN_KEYCHAIN="$HOME/Library/Keychains/login.keychain-db"
+else
+    CERT="kapture-dev"
+    echo "Using self-signed identity 'kapture-dev'"
+    SIGN_KEYCHAIN="$KEYCHAIN"
+fi
+DEV_IDENT="${DEV_IDENT:-}"  # ensure set for later use
+
 if [ ! -f "$KEYCHAIN" ]; then
     security create-keychain -p "$KCHAIN_PASS" "$KEYCHAIN" 2>/dev/null
     security set-keychain-settings -lut 86400 "$KEYCHAIN"
@@ -86,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.0</string>
+    <string>1.1.7</string>
     <key>CFBundleVersion</key>
-    <string>1</string>
+    <string>17</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>
@@ -102,6 +124,14 @@ PLIST
 chmod +x scripts/make-icon.sh
 ./scripts/make-icon.sh
 
-codesign --force --sign "$CERT" --keychain "$KEYCHAIN" "$APP"
+if [ -n "$SIGN_KEYCHAIN" ]; then
+    codesign --force --options runtime --sign "$CERT" --keychain "$SIGN_KEYCHAIN" "$APP"
+else
+    codesign --force --sign "$CERT" "$APP"
+fi
 
+if [ -n "$DEV_IDENT" ]; then
+    echo "Built $APP (signed with Developer ID '$CERT') — drag to /Applications or run: open $APP"
+else
     echo "Built $APP (signed with stable identity '$CERT') — drag to /Applications or run: open $APP"
+fi

release.sh

@@ -8,14 +8,83 @@ if [ "$#" -ne 1 ]; then
 fi
 VERSION="$1"
 
+# Notarization credentials. Configure once, e.g. in ~/.zshrc:
+#   export KAPTURE_NOTARY_ASC_PROVIDER="<TeamID>"
+#   export KAPTURE_NOTARY_API_KEY_PATH="$HOME/.config/kapture/AuthKey_XXXX.p8"
+#   export KAPTURE_NOTARY_API_KEY_ID="<KeyID>"
+#   export KAPTURE_NOTARY_API_ISSUER="<IssuerID>"
+# If these are unset (or KAPTURE_SKIP_NOTARY=1), release.sh builds, zips, and stops
+# there — the zip is signed with the Developer ID identity but NOT notarized.
+
 ./build-app.sh
 
 mkdir -p dist
 rm -f dist/Kapture.zip
 ditto -c -k --keepParent Kapture.app dist/Kapture.zip
-shasum -a 256 dist/Kapture.zip
 
+if [ -n "${KAPTURE_SKIP_NOTARY:-}" ]; then
+    echo
+    echo "Skipping notarization (KAPTURE_SKIP_NOTARY set)."
+    shasum -a 256 dist/Kapture.zip
     echo
     echo "Tag and release with:"
     echo "  git tag v$VERSION && git push origin v$VERSION"
-echo "The GitHub Actions release workflow will upload dist/Kapture.zip automatically."
+    echo "Attach dist/Kapture.zip to the GitHub release manually."
+    exit 0
+fi
+
+REQUIRED_VARS="KAPTURE_NOTARY_ASC_PROVIDER KAPTURE_NOTARY_API_KEY_PATH KAPTURE_NOTARY_API_KEY_ID KAPTURE_NOTARY_API_ISSUER"
+MISSING=""
+for v in $REQUIRED_VARS; do
+    if [ -z "${!v:-}" ]; then
+        MISSING="$MISSING $v"
+    fi
+done
+if [ -n "$MISSING" ]; then
+    echo "Notarization skipped — missing env var(s):$MISSING (see header comments)." >&2
+    shasum -a 256 dist/Kapture.zip
+    echo
+    echo "The zip above is signed but NOT notarized; Gatekeeper will warn users until it is."
+    echo "Set the KAPTURE_NOTARY_* variables and re-run ./release.sh $VERSION."
+    exit 0
+fi
+
+if ! command -v xcrun >/dev/null 2>&1 || ! xcrun --find notarytool >/dev/null 2>&1; then
+    echo "Notarization skipped — xcrun notarytool not found (requires Xcode 13+)." >&2
+    shasum -a 256 dist/Kapture.zip
+    exit 0
+fi
+
+echo "Submitting to Apple for notarization (first run can take minutes)..."
+xcrun notarytool submit dist/Kapture.zip \
+    --key "$KAPTURE_NOTARY_API_KEY_PATH" \
+    --key-id "$KAPTURE_NOTARY_API_KEY_ID" \
+    --issuer "$KAPTURE_NOTARY_API_ISSUER" \
+    --wait \
+    --output-format json > notary-result.json
+
+STATUS=$(jq -r '.status' notary-result.json 2>/dev/null || echo "unknown")
+if [ "$STATUS" != "Accepted" ]; then
+    echo "Notarization failed with status: $STATUS" >&2
+    if [ -f notary-result.json ]; then
+        cat notary-result.json >&2
+        rm -f notary-result.json
+    fi
+    exit 1
+fi
+rm -f notary-result.json
+
+echo "Notarization accepted — stapling ticket onto the app..."
+xcrun stapler staple Kapture.app
+xcrun stapler validate Kapture.app
+
+rm -f dist/Kapture.zip
+ditto -c -k --keepParent Kapture.app dist/Kapture.zip
+
+echo
+echo "Done — notarized."
+shasum -a 256 dist/Kapture.zip
+echo
+echo "Tag and release with:"
+echo "  git tag v$VERSION && git push origin v$VERSION"
+echo "Attach dist/Kapture.zip to the GitHub release manually; the Homebrew cask is ready."