Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
fix(hotkey): isolate mouse event taps
altic-dev33e4eb5d6e70
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swiftindex 024e355c..2845e920 100644--- a/Sources/Fluid/ContentView.swift+++ b/Sources/Fluid/ContentView.swift@@ -474,8 +474,8 @@ struct ContentView: View {self.handleRewriteShortcutEnabledChange(newValue)}.onChange(of: self.pasteLastTranscriptionHotkeyShortcut) { _, newValue in- // The hotkey manager reads this value live from SettingsStore, so persisting is enough.SettingsStore.shared.pasteLastTranscriptionHotkeyShortcut = newValue+ self.hotkeyManager?.refreshMouseShortcutTapIfNeeded()}.onChange(of: self.isPasteLastTranscriptionShortcutEnabled) { newValue inself.handlePasteLastTranscriptionShortcutEnabledChange(newValue)@@ -484,6 +484,7 @@ struct ContentView: View {private func handlePasteLastTranscriptionShortcutEnabledChange(_ isEnabled: Bool) {SettingsStore.shared.pasteLastTranscriptionShortcutEnabled = isEnabled+ self.hotkeyManager?.refreshMouseShortcutTapIfNeeded()if !isEnabled, self.activeShortcutRecordingTarget == .pasteLast {self.clearShortcutRecordingMode()}diff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swiftindex 0ca8b2f1..2e41480b 100644--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift@@ -218,6 +218,7 @@ private final nonisolated class HotkeyState: @unchecked Sendable {var automaticPressWasTargetActive: [HotkeyHoldModeType: Bool] = [:]var automaticPressStartedTypes: Set<HotkeyHoldModeType> = []var activePrimaryShortcutPress: ActivePrimaryShortcutPress?+ var consumedPasteMouseButton: Int?func withLock<T>(_ block: () -> T) -> T {self.lock.lock()@@ -231,6 +232,11 @@ final class GlobalHotkeyManager: NSObject {private nonisolated(unsafe) var state = HotkeyState()private nonisolated(unsafe) var eventTap: CFMachPort?private nonisolated(unsafe) var runLoopSource: CFRunLoopSource?+ private nonisolated(unsafe) var mouseObserverTap: CFMachPort?+ private nonisolated(unsafe) var mouseObserverSource: CFRunLoopSource?+ private nonisolated(unsafe) var mouseShortcutTap: CFMachPort?+ private nonisolated(unsafe) var mouseShortcutSource: CFRunLoopSource?+ private nonisolated(unsafe) var monitoredMouseButtons: Set<Int> = []private let asrService: ASRServiceprivate var primaryShortcuts: [HotkeyShortcut]private var promptModeShortcut: HotkeyShortcut@@ -457,6 +463,7 @@ final class GlobalHotkeyManager: NSObject {private var maxRetryAttempts = 5private var retryDelay: TimeInterval = 0.5private var healthCheckInterval: TimeInterval = 30.0+ private var activeShortcutLogScheduled = falseinit(asrService: ASRService,@@ -510,11 +517,15 @@ final class GlobalHotkeyManager: NSObject {private func initializeWithDelay() {DebugLogger.shared.debug("Starting delayed initialization...", source: "GlobalHotkeyManager")- self.initializationTask = Task {- try? await Task.sleep(nanoseconds: 1_500_000_000) // 1.5 second delay+ self.initializationTask = Task { [weak self] in+ do {+ try await Task.sleep(nanoseconds: 1_500_000_000) // 1.5 second delay+ } catch {+ return+ }- await MainActor.run {- self.setupGlobalHotkeyWithRetry()+ await MainActor.run { [weak self] in+ self?.setupGlobalHotkeyWithRetry()}}}@@ -530,11 +541,21 @@ final class GlobalHotkeyManager: NSObject {func updatePrimaryShortcuts(_ newShortcuts: [HotkeyShortcut]) {self.primaryShortcuts = newShortcutsDebugLogger.shared.info("Updated transcription hotkeys", source: "GlobalHotkeyManager")+ self.refreshMouseShortcutTapIfNeeded()+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")+ }++ func refreshMouseShortcutTapIfNeeded() {+ guard self.eventTap != nil else { return }+ let mouseButtons = self.configuredMouseButtons()+ guard mouseButtons != self.monitoredMouseButtons else { return }+ self.setupMouseShortcutTap(mouseButtons: mouseButtons)}func updateCommandModeShortcut(_ newShortcut: HotkeyShortcut?) {self.commandModeShortcut = newShortcutDebugLogger.shared.info("Updated command mode hotkey", source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func setRewriteModeCallback(_ callback: @escaping () async -> Void) {@@ -544,6 +565,7 @@ final class GlobalHotkeyManager: NSObject {func updateRewriteModeShortcut(_ newShortcut: HotkeyShortcut) {self.rewriteModeShortcut = newShortcutDebugLogger.shared.info("Updated rewrite mode hotkey", source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func updateCommandModeShortcutEnabled(_ enabled: Bool) {@@ -555,6 +577,7 @@ final class GlobalHotkeyManager: NSObject {"Command mode shortcut \(enabled ? "enabled" : "disabled")",source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func updateRewriteModeShortcutEnabled(_ enabled: Bool) {@@ -566,6 +589,7 @@ final class GlobalHotkeyManager: NSObject {"Rewrite mode shortcut \(enabled ? "enabled" : "disabled")",source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func setPromptModeCallback(_ callback: @escaping () async -> Void) {@@ -575,6 +599,7 @@ final class GlobalHotkeyManager: NSObject {func updatePromptModeShortcut(_ newShortcut: HotkeyShortcut) {self.promptModeShortcut = newShortcutDebugLogger.shared.info("Updated prompt mode hotkey", source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func updatePromptModeShortcutEnabled(_ enabled: Bool) {@@ -586,11 +611,13 @@ final class GlobalHotkeyManager: NSObject {"Prompt mode shortcut \(enabled ? "enabled" : "disabled")",source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func updatePromptShortcutAssignments(_ assignments: [(selection: SettingsStore.DictationPromptSelection, shortcut: HotkeyShortcut)]) {self.promptShortcutAssignments = assignmentsDebugLogger.shared.info("Updated prompt shortcut assignments", source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func setCancelCallback(_ callback: @escaping () -> Bool) {@@ -636,21 +663,11 @@ final class GlobalHotkeyManager: NSObject {return false}- let eventMask = (1 << CGEventType.keyDown.rawValue)- | (1 << CGEventType.keyUp.rawValue)- | (1 << CGEventType.flagsChanged.rawValue)- | (1 << CGEventType.leftMouseDown.rawValue)- | (1 << CGEventType.leftMouseUp.rawValue)- | (1 << CGEventType.rightMouseDown.rawValue)- | (1 << CGEventType.rightMouseUp.rawValue)- | (1 << CGEventType.otherMouseDown.rawValue)- | (1 << CGEventType.otherMouseUp.rawValue)-self.eventTap = CGEvent.tapCreate(tap: .cgSessionEventTap,place: .headInsertEventTap,options: .defaultTap,- eventsOfInterest: CGEventMask(eventMask),+ eventsOfInterest: Self.keyboardEventMask(),callback: { proxy, type, event, refcon -> Unmanaged<CGEvent>? inguard let refcon = refcon else { return Unmanaged.passUnretained(event) }let manager = Unmanaged<GlobalHotkeyManager>.fromOpaque(refcon)@@ -681,21 +698,329 @@ final class GlobalHotkeyManager: NSObject {}DebugLogger.shared.info("Event tap successfully created and enabled", source: "GlobalHotkeyManager")+ self.logActiveShortcuts(reason: "event tap ready")+ self.setupMouseTaps()return true}private nonisolated func cleanupEventTap() {- if let tap = eventTap {+ Self.tearDown(tap: self.eventTap, source: self.runLoopSource)+ self.eventTap = nil+ self.runLoopSource = nil+ self.clearPrimaryShortcutPressState()+ self.cleanupMouseTaps()+ }++ private nonisolated static func tearDown(tap: CFMachPort?, source: CFRunLoopSource?) {+ if let tap {CGEvent.tapEnable(tap: tap, enable: false)+ CFMachPortInvalidate(tap)}-- if let source = runLoopSource {+ if let source {CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes)+ CFRunLoopSourceInvalidate(source)}+ }- self.eventTap = nil- self.runLoopSource = nil- self.clearPrimaryShortcutPressState()+ nonisolated static func keyboardEventMask() -> CGEventMask {+ (CGEventMask(1) << CGEventType.keyDown.rawValue)+ | (CGEventMask(1) << CGEventType.keyUp.rawValue)+ | (CGEventMask(1) << CGEventType.flagsChanged.rawValue)+ }++ nonisolated static func mouseObserverEventMask() -> CGEventMask {+ (CGEventMask(1) << CGEventType.leftMouseDown.rawValue)+ | (CGEventMask(1) << CGEventType.rightMouseDown.rawValue)+ | (CGEventMask(1) << CGEventType.otherMouseDown.rawValue)+ }++ nonisolated static func mouseShortcutEventMask(mouseButtons: Set<Int>) -> CGEventMask {+ var mask: CGEventMask = 0+ if mouseButtons.contains(0) {+ mask |= (CGEventMask(1) << CGEventType.leftMouseDown.rawValue)+ | (CGEventMask(1) << CGEventType.leftMouseUp.rawValue)+ }+ if mouseButtons.contains(1) {+ mask |= (CGEventMask(1) << CGEventType.rightMouseDown.rawValue)+ | (CGEventMask(1) << CGEventType.rightMouseUp.rawValue)+ }+ if mouseButtons.contains(where: { $0 >= 2 }) {+ mask |= (CGEventMask(1) << CGEventType.otherMouseDown.rawValue)+ | (CGEventMask(1) << CGEventType.otherMouseUp.rawValue)+ }+ return mask+ }++ struct ActiveShortcutSummaryInput {+ let primary: [HotkeyShortcut]+ let promptAssignments: [(key: String, shortcut: HotkeyShortcut)]+ let secondaryPromptMode: HotkeyShortcut+ let secondaryPromptModeEnabled: Bool+ let command: HotkeyShortcut?+ let commandEnabled: Bool+ let edit: HotkeyShortcut+ let editEnabled: Bool+ let cancel: HotkeyShortcut+ let pasteLast: HotkeyShortcut?+ let pasteLastEnabled: Bool+ let mode: HotkeyActivationMode+ }++ /// One line listing every shortcut the manager will act on and where it came from.+ static func activeShortcutSummary(_ input: ActiveShortcutSummaryInput) -> String {+ func describe(_ shortcut: HotkeyShortcut?) -> String {+ guard let shortcut else { return "none" }+ if shortcut.isMouseShortcut {+ return "\(shortcut.displayString) [button=\(shortcut.mouseButton ?? -1) flags=\(shortcut.relevantModifierFlags.rawValue)]"+ }+ return "\(shortcut.displayString) [keyCode=\(shortcut.keyCode) flags=\(shortcut.relevantModifierFlags.rawValue)]"+ }++ var parts = ["mode=\(input.mode.rawValue)"]+ parts += input.primary.enumerated().map { "primary[\($0.offset)]=\(describe($0.element))" }+ parts += input.promptAssignments.map { "prompt[\($0.key)]=\(describe($0.shortcut))" }+ parts.append("secondaryPromptMode=\(describe(input.secondaryPromptMode)) enabled=\(input.secondaryPromptModeEnabled)")+ parts.append("command=\(describe(input.command)) enabled=\(input.commandEnabled)")+ parts.append("edit=\(describe(input.edit)) enabled=\(input.editEnabled)")+ parts.append("cancel=\(describe(input.cancel))")+ parts.append("pasteLast=\(describe(input.pasteLast)) enabled=\(input.pasteLastEnabled)")+ return parts.joined(separator: " | ")+ }++ /// Coalesces the burst of shortcut updates into one log line.+ private func scheduleActiveShortcutLog(reason: String) {+ guard !self.activeShortcutLogScheduled else { return }+ self.activeShortcutLogScheduled = true+ Task { @MainActor [weak self] in+ guard let self else { return }+ self.activeShortcutLogScheduled = false+ self.logActiveShortcuts(reason: reason)+ }+ }++ private func logActiveShortcuts(reason: String) {+ let settings = SettingsStore.shared+ let promptAssignments = self.promptShortcutAssignments.map { assignment in+ (+ key: settings.dictationPromptConfigurationKey(for: assignment.selection) ?? "?",+ shortcut: assignment.shortcut+ )+ }+ let summary = Self.activeShortcutSummary(.init(+ primary: self.primaryShortcuts,+ promptAssignments: promptAssignments,+ secondaryPromptMode: self.promptModeShortcut,+ secondaryPromptModeEnabled: self.promptModeShortcutEnabled,+ command: self.commandModeShortcut,+ commandEnabled: self.commandModeShortcutEnabled,+ edit: self.rewriteModeShortcut,+ editEnabled: self.rewriteModeShortcutEnabled,+ cancel: settings.cancelRecordingHotkeyShortcut,+ pasteLast: settings.pasteLastTranscriptionHotkeyShortcut,+ pasteLastEnabled: settings.pasteLastTranscriptionShortcutEnabled,+ mode: self.hotkeyMode+ ))+ DebugLogger.shared.info("Active shortcuts (\(reason)) | \(summary)", source: "GlobalHotkeyManager")+ }++ nonisolated static func modifierFlags(from flags: CGEventFlags) -> NSEvent.ModifierFlags {+ var modifiers: NSEvent.ModifierFlags = []+ if flags.contains(.maskSecondaryFn) { modifiers.insert(.function) }+ if flags.contains(.maskCommand) { modifiers.insert(.command) }+ if flags.contains(.maskAlternate) { modifiers.insert(.option) }+ if flags.contains(.maskControl) { modifiers.insert(.control) }+ if flags.contains(.maskShift) { modifiers.insert(.shift) }+ return modifiers+ }++ private nonisolated static func isTapEnabled(_ tap: CFMachPort?) -> Bool {+ guard let tap else { return false }+ return CGEvent.tapIsEnabled(tap: tap)+ }++ private func configuredMouseButtons() -> Set<Int> {+ var buttons = Set(self.primaryShortcuts.compactMap { shortcut in+ shortcut.isMouseShortcut ? shortcut.mouseButton : nil+ })++ if SettingsStore.shared.pasteLastTranscriptionShortcutEnabled,+ let shortcut = SettingsStore.shared.pasteLastTranscriptionHotkeyShortcut,+ shortcut.isMouseShortcut,+ let mouseButton = shortcut.mouseButton+ {+ buttons.insert(mouseButton)+ }++ return buttons+ }++ private func setupMouseTaps() {+ self.setupMouseObserverTap()+ self.setupMouseShortcutTap(mouseButtons: self.configuredMouseButtons())+ }++ // Listen-only: macOS delivers clicks to apps whether or not this callback runs.+ private func setupMouseObserverTap() {+ self.cleanupMouseObserverTap()++ guard let tap = CGEvent.tapCreate(+ tap: .cgSessionEventTap,+ place: .headInsertEventTap,+ options: .listenOnly,+ eventsOfInterest: Self.mouseObserverEventMask(),+ callback: { _, type, event, refcon -> Unmanaged<CGEvent>? in+ guard let refcon else { return Unmanaged.passUnretained(event) }+ let manager = Unmanaged<GlobalHotkeyManager>.fromOpaque(refcon).takeUnretainedValue()+ return manager.handleMouseObserverEvent(type: type, event: event)+ },+ userInfo: Unmanaged.passUnretained(self).toOpaque()+ ) else {+ DebugLogger.shared.error("Failed to create mouse observer tap", source: "GlobalHotkeyManager")+ return+ }++ guard let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0) else {+ CFMachPortInvalidate(tap)+ DebugLogger.shared.error("Failed to create mouse observer run loop source", source: "GlobalHotkeyManager")+ return+ }++ self.mouseObserverTap = tap+ self.mouseObserverSource = source+ CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)+ CGEvent.tapEnable(tap: tap, enable: true)+ DebugLogger.shared.info("Mouse observer tap enabled (listen-only)", source: "GlobalHotkeyManager")+ }++ // Filter tap, created only for the button families that have a shortcut.+ private func setupMouseShortcutTap(mouseButtons: Set<Int>) {+ self.cleanupMouseShortcutTap()++ let mask = Self.mouseShortcutEventMask(mouseButtons: mouseButtons)+ guard mask != 0 else {+ DebugLogger.shared.info("Mouse shortcut tap not needed [mouseButtons=none]", source: "GlobalHotkeyManager")+ return+ }++ guard let tap = CGEvent.tapCreate(+ tap: .cgSessionEventTap,+ place: .headInsertEventTap,+ options: .defaultTap,+ eventsOfInterest: mask,+ callback: { _, type, event, refcon -> Unmanaged<CGEvent>? in+ guard let refcon else { return Unmanaged.passUnretained(event) }+ let manager = Unmanaged<GlobalHotkeyManager>.fromOpaque(refcon).takeUnretainedValue()+ return manager.handleMouseShortcutEvent(type: type, event: event)+ },+ userInfo: Unmanaged.passUnretained(self).toOpaque()+ ) else {+ DebugLogger.shared.error("Failed to create mouse shortcut tap", source: "GlobalHotkeyManager")+ return+ }++ guard let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0) else {+ CFMachPortInvalidate(tap)+ DebugLogger.shared.error("Failed to create mouse shortcut run loop source", source: "GlobalHotkeyManager")+ return+ }++ self.mouseShortcutTap = tap+ self.mouseShortcutSource = source+ self.monitoredMouseButtons = mouseButtons+ CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)+ CGEvent.tapEnable(tap: tap, enable: true)+ let summary = mouseButtons.sorted().map(String.init).joined(separator: ",")+ DebugLogger.shared.info("Mouse shortcut tap enabled [mouseButtons=\(summary)]", source: "GlobalHotkeyManager")+ }++ private func recoverMouseTapsIfNeeded() {+ if !Self.isTapEnabled(self.mouseObserverTap) {+ DebugLogger.shared.warning("Mouse observer tap not enabled, rebuilding", source: "GlobalHotkeyManager")+ self.setupMouseObserverTap()+ }++ let mouseButtons = self.configuredMouseButtons()+ let shortcutTapMissing = !mouseButtons.isEmpty && !Self.isTapEnabled(self.mouseShortcutTap)+ if mouseButtons != self.monitoredMouseButtons || shortcutTapMissing {+ DebugLogger.shared.warning("Mouse shortcut tap out of date, rebuilding", source: "GlobalHotkeyManager")+ self.setupMouseShortcutTap(mouseButtons: mouseButtons)+ }+ }++ private nonisolated func cleanupMouseTaps() {+ self.cleanupMouseObserverTap()+ self.cleanupMouseShortcutTap()+ }++ private nonisolated func cleanupMouseObserverTap() {+ Self.tearDown(tap: self.mouseObserverTap, source: self.mouseObserverSource)+ self.mouseObserverTap = nil+ self.mouseObserverSource = nil+ }++ private nonisolated func cleanupMouseShortcutTap() {+ Self.tearDown(tap: self.mouseShortcutTap, source: self.mouseShortcutSource)+ self.mouseShortcutTap = nil+ self.mouseShortcutSource = nil+ self.monitoredMouseButtons = []+ self.clearPrimaryShortcutPressState(mouseOnly: true)+ }++ private func handleMouseObserverEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {+ if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {+ self.reenableMouseTap(self.mouseObserverTap, label: "Mouse observer") { self.setupMouseObserverTap() }+ return Unmanaged.passUnretained(event)+ }++ if self.isShortcutCaptureActiveProvider?() ?? false {+ return Unmanaged.passUnretained(event)+ }++ self.markOtherInputDuringModifierOnly()+ return Unmanaged.passUnretained(event)+ }++ private func handleMouseShortcutEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {+ if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {+ self.clearPrimaryShortcutPressState(mouseOnly: true)+ self.reenableMouseTap(self.mouseShortcutTap, label: "Mouse shortcut") {+ self.setupMouseShortcutTap(mouseButtons: self.configuredMouseButtons())+ }+ return Unmanaged.passUnretained(event)+ }++ if self.isShortcutCaptureActiveProvider?() ?? false {+ return Unmanaged.passUnretained(event)+ }++ switch type {+ case .leftMouseDown, .rightMouseDown, .otherMouseDown:+ self.markOtherInputDuringModifierOnly()+ if self.handleMouseShortcutDown(event, modifiers: Self.modifierFlags(from: event.flags)) {+ return nil+ }+ case .leftMouseUp, .rightMouseUp, .otherMouseUp:+ if self.handleMouseShortcutUp(event) {+ return nil+ }+ default:+ break+ }++ return Unmanaged.passUnretained(event)+ }++ private func reenableMouseTap(_ tap: CFMachPort?, label: String, rebuild: @escaping @MainActor () -> Void) {+ DebugLogger.shared.warning("\(label) tap disabled by macOS, re-enabling", source: "GlobalHotkeyManager")+ if let tap {+ CGEvent.tapEnable(tap: tap, enable: true)+ }+ guard !Self.isTapEnabled(tap) else { return }++ DebugLogger.shared.warning("\(label) tap re-enable failed, rebuilding", source: "GlobalHotkeyManager")+ Task { @MainActor in+ rebuild()+ }}nonisolated static func sessionIsLocked(sessionInfo: [String: Any]) -> Bool {@@ -706,9 +1031,14 @@ final class GlobalHotkeyManager: NSObject {self.sessionIsLocked(sessionInfo: CGSessionCopyCurrentDictionary() as? [String: Any] ?? [:])}- private nonisolated func clearPrimaryShortcutPressState() {+ private nonisolated func clearPrimaryShortcutPressState(mouseOnly: Bool = false) {let task = self.state.withLock { () -> Task<Void, Never>? in- guard self.state.activePrimaryShortcutPress != nil || self.state.isKeyPressed else { return nil }+ self.state.consumedPasteMouseButton = nil+ if mouseOnly {+ guard case .mouse? = self.state.activePrimaryShortcutPress else { return nil }+ } else {+ guard self.state.activePrimaryShortcutPress != nil || self.state.isKeyPressed else { return nil }+ }self.state.activePrimaryShortcutPress = nilself.state.isKeyPressed = falseself.state.holdModeStartTriggeredTypes.remove(.transcription)@@ -800,14 +1130,7 @@ final class GlobalHotkeyManager: NSObject {}let keyCode = UInt16(event.getIntegerValueField(.keyboardEventKeycode))- let flags = event.flags-- var eventModifiers: NSEvent.ModifierFlags = []- if flags.contains(.maskSecondaryFn) { eventModifiers.insert(.function) }- if flags.contains(.maskCommand) { eventModifiers.insert(.command) }- if flags.contains(.maskAlternate) { eventModifiers.insert(.option) }- if flags.contains(.maskControl) { eventModifiers.insert(.control) }- if flags.contains(.maskShift) { eventModifiers.insert(.shift) }+ let eventModifiers = Self.modifierFlags(from: event.flags)switch type {case .keyDown:@@ -1082,17 +1405,6 @@ final class GlobalHotkeyManager: NSObject {return nil}- case .leftMouseDown, .rightMouseDown, .otherMouseDown:- self.markOtherInputDuringModifierOnly()- if self.handleMouseShortcutDown(event, modifiers: eventModifiers) {- return nil- }-- case .leftMouseUp, .rightMouseUp, .otherMouseUp:- if self.handleMouseShortcutUp(event) {- return nil- }-case .flagsChanged:if HotkeyShortcut.modifierFlag(forKeyCode: keyCode) != nil {self.pressedModifierKeyCodes = self.synchronizedPressedModifierKeyCodes(@@ -1801,6 +2113,7 @@ final class GlobalHotkeyManager: NSObject {let pasteShortcut = SettingsStore.shared.pasteLastTranscriptionHotkeyShortcut,pasteShortcut.matchesMouse(button: mouseButton, modifiers: eventModifiers){+ self.state.withLock { self.state.consumedPasteMouseButton = mouseButton }self.triggerPasteLastTranscription(isAutorepeat: false)return true}@@ -1814,16 +2127,16 @@ final class GlobalHotkeyManager: NSObject {return false}- /// Handles a mouse-button up event. Swallows the up that pairs with a consumed paste mouse-down- /// so the focused app never sees an orphaned mouse-up; otherwise ends a primary dictation press.+ /// Swallows only the mouse-up that pairs with a mouse-down this tap consumed.private func handleMouseShortcutUp(_ event: CGEvent) -> Bool {let mouseButton = self.mouseButton(from: event)- if SettingsStore.shared.pasteLastTranscriptionShortcutEnabled,- let pasteShortcut = SettingsStore.shared.pasteLastTranscriptionHotkeyShortcut,- pasteShortcut.isMouseShortcut,- pasteShortcut.mouseButton == mouseButton- {+ let consumedPasteDown = self.state.withLock { () -> Bool in+ guard self.state.consumedPasteMouseButton == mouseButton else { return false }+ self.state.consumedPasteMouseButton = nil+ return true+ }+ if consumedPasteDown {return true}@@ -1898,6 +2211,7 @@ final class GlobalHotkeyManager: NSObject {self.stopRecordingIfNeeded()}DebugLogger.shared.info("Hotkey activation mode set to \(mode.displayName)", source: "GlobalHotkeyManager")+ self.scheduleActiveShortcutLog(reason: "shortcuts updated")}func enablePressAndHoldMode(_ enable: Bool) {@@ -2032,13 +2346,19 @@ final class GlobalHotkeyManager: NSObject {private func startHealthCheckTimer() {self.healthCheckTask?.cancel()- self.healthCheckTask = Task {+ self.healthCheckTask = Task { [weak self] inwhile !Task.isCancelled {- try? await Task.sleep(nanoseconds: UInt64(self.healthCheckInterval * 1_000_000_000))+ guard let healthCheckInterval = self?.healthCheckInterval else { break }+ do {+ try await Task.sleep(nanoseconds: UInt64(healthCheckInterval * 1_000_000_000))+ } catch {+ break+ }guard !Task.isCancelled else { break }- await MainActor.run {+ await MainActor.run { [weak self] in+ guard let self else { return }if !self.validateEventTapHealth() {DebugLogger.shared.warning("Health check failed, attempting to recover", source: "GlobalHotkeyManager")@@ -2049,6 +2369,8 @@ final class GlobalHotkeyManager: NSObject {DebugLogger.shared.error("Health check recovery failed", source: "GlobalHotkeyManager")self.isInitialized = false}+ } else {+ self.recoverMouseTapsIfNeeded()}}}diff --git a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swiftindex b5135751..4d8a448b 100644--- a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift+++ b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift@@ -19,6 +19,88 @@ final class HotkeyShortcutTests: XCTestCase {private let experimentalDirectAudioCaptureEnabledKey = "ExperimentalDirectAudioCaptureEnabled"private let incrementalParakeetEnabledKey = "ExperimentalParakeetUnifiedFinalEnabled"+ @MainActor+ func testActiveShortcutSummaryListsEverySourceWithKeyCodes() {+ let summary = GlobalHotkeyManager.activeShortcutSummary(.init(+ primary: [HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])],+ promptAssignments: [(key: "__default__", shortcut: HotkeyShortcut(keyCode: 55, modifierFlags: [], modifierKeyCodes: [55]))],+ secondaryPromptMode: HotkeyShortcut(keyCode: 60, modifierFlags: []),+ secondaryPromptModeEnabled: false,+ command: nil,+ commandEnabled: false,+ edit: HotkeyShortcut(keyCode: 15, modifierFlags: [.option]),+ editEnabled: true,+ cancel: HotkeyShortcut(keyCode: 53, modifierFlags: []),+ pasteLast: HotkeyShortcut(mouseButton: 0, modifierFlags: [.command]),+ pasteLastEnabled: true,+ mode: .automatic+ ))++ XCTAssertTrue(summary.hasPrefix("mode=automatic"))+ XCTAssertTrue(summary.contains("primary[0]=Right ⌥ [keyCode=61"), summary)+ XCTAssertTrue(summary.contains("prompt[__default__]=Left ⌘ [keyCode=55"), summary)+ XCTAssertTrue(summary.contains("secondaryPromptMode=Right ⇧ [keyCode=60 flags=0] enabled=false"), summary)+ XCTAssertTrue(summary.contains("command=none enabled=false"), summary)+ XCTAssertTrue(summary.contains("edit=⌥ + R [keyCode=15"), summary)+ XCTAssertTrue(summary.contains("cancel=Escape [keyCode=53"), summary)+ XCTAssertTrue(summary.contains("pasteLast=⌘ + Left Click [button=0"), summary)+ }++ func testKeyboardEventMaskExcludesMouseEvents() {+ let mask = GlobalHotkeyManager.keyboardEventMask()+ for type in [CGEventType.keyDown, .keyUp, .flagsChanged] {+ XCTAssertNotEqual(mask & (CGEventMask(1) << type.rawValue), 0, "keyboard mask must include \(type)")+ }+ for type in [CGEventType.leftMouseDown, .leftMouseUp, .rightMouseDown, .rightMouseUp, .otherMouseDown, .otherMouseUp] {+ XCTAssertEqual(mask & (CGEventMask(1) << type.rawValue), 0, "keyboard mask must not include \(type)")+ }+ }++ func testMouseObserverMaskCoversOnlyMouseDowns() {+ let mask = GlobalHotkeyManager.mouseObserverEventMask()+ for type in [CGEventType.leftMouseDown, .rightMouseDown, .otherMouseDown] {+ XCTAssertNotEqual(mask & (CGEventMask(1) << type.rawValue), 0, "observer mask must include \(type)")+ }+ for type in [CGEventType.leftMouseUp, .rightMouseUp, .otherMouseUp, .keyDown, .keyUp, .flagsChanged] {+ XCTAssertEqual(mask & (CGEventMask(1) << type.rawValue), 0, "observer mask must not include \(type)")+ }+ }++ func testMouseShortcutMaskMatchesConfiguredButtons() {+ XCTAssertEqual(GlobalHotkeyManager.mouseShortcutEventMask(mouseButtons: []), 0)++ let leftOnly = GlobalHotkeyManager.mouseShortcutEventMask(mouseButtons: [0])+ for type in [CGEventType.leftMouseDown, .leftMouseUp] {+ XCTAssertNotEqual(leftOnly & (CGEventMask(1) << type.rawValue), 0)+ }+ for type in [CGEventType.rightMouseDown, .rightMouseUp, .otherMouseDown, .otherMouseUp, .keyDown, .flagsChanged] {+ XCTAssertEqual(leftOnly & (CGEventMask(1) << type.rawValue), 0, "left-only mask must not include \(type)")+ }++ let sideButton = GlobalHotkeyManager.mouseShortcutEventMask(mouseButtons: [3])+ for type in [CGEventType.otherMouseDown, .otherMouseUp] {+ XCTAssertNotEqual(sideButton & (CGEventMask(1) << type.rawValue), 0)+ }+ for type in [CGEventType.leftMouseDown, .leftMouseUp, .rightMouseDown, .rightMouseUp] {+ XCTAssertEqual(sideButton & (CGEventMask(1) << type.rawValue), 0, "side-button mask must not include \(type)")+ }+ }++ func testModifierOnlyShortcutIgnoresTapAfterMouseClick() {+ let replay = ModifierOnlyFlagsReplay(+ shortcut: HotkeyShortcut(keyCode: 58, modifierFlags: .option, modifierKeyCodes: [58])+ )++ replay.flagsChanged(keyCode: 58, modifiers: .option, nextPressed: [58])+ XCTAssertEqual(replay.activeModifierOnlyType, .transcription)++ replay.mouseDown()+ replay.flagsChanged(keyCode: 58, modifiers: [], nextPressed: [])++ XCTAssertEqual(replay.cleanFinishCount, 0, "Option+click must not read as an Option tap")+ XCTAssertNil(replay.activeModifierOnlyType)+ }+func testHotkeySessionLockDetection() {XCTAssertTrue(GlobalHotkeyManager.sessionIsLocked(sessionInfo: ["CGSSessionScreenIsLocked": true]))XCTAssertFalse(GlobalHotkeyManager.sessionIsLocked(sessionInfo: ["CGSSessionScreenIsLocked": false]))@@ -1991,4 +2073,9 @@ private final class ModifierOnlyFlagsReplay {self.otherKeyPressedDuringModifier = true}}++ /// Same mark as keyDown; the mouse observer tap calls markOtherInputDuringModifierOnly too.+ func mouseDown() {+ self.keyDown()+ }}