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
feat(typing): verify paste landed by reading focus back
altic-devfadaed91274d
diff --git a/Sources/Fluid/Analytics/AnalyticsEvent.swift b/Sources/Fluid/Analytics/AnalyticsEvent.swiftindex 5b623c07..15c8ff52 100644--- a/Sources/Fluid/Analytics/AnalyticsEvent.swift+++ b/Sources/Fluid/Analytics/AnalyticsEvent.swift@@ -87,6 +87,7 @@ enum AnalyticsInsertionOutcome: String {case targetUnavailable = "target_unavailable"case targetRestoreFailed = "target_restore_failed"case noEditableTarget = "no_editable_target"+ case pasteNotLanded = "paste_not_landed"}struct AnalyticsModelDescriptor: Equatable {diff --git a/Sources/Fluid/Services/GlobalHotkeyManager+DebugTrigger.swift b/Sources/Fluid/Services/GlobalHotkeyManager+DebugTrigger.swiftindex 0ee889c9..a5ae0000 100644--- a/Sources/Fluid/Services/GlobalHotkeyManager+DebugTrigger.swift+++ b/Sources/Fluid/Services/GlobalHotkeyManager+DebugTrigger.swift@@ -17,6 +17,16 @@ extension GlobalHotkeyManager {self?.toggleRecording()}}+ DistributedNotificationCenter.default().addObserver(+ forName: Notification.Name("com.FluidApp.debug.pasteLastTranscript"),+ object: nil,+ queue: .main+ ) { [weak self] _ in+ Task { @MainActor [weak self] in+ DebugLogger.shared.info("Debug paste-last trigger received", source: "GlobalHotkeyManager")+ self?.triggerPasteLastTranscription(isAutorepeat: false)+ }+ }DebugLogger.shared.info("Debug toggle trigger enabled", source: "GlobalHotkeyManager")}}diff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swiftindex 7be63684..b0a4754a 100644--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift@@ -2269,7 +2269,7 @@ final class GlobalHotkeyManager: NSObject {return true}- private func triggerPasteLastTranscription(isAutorepeat: Bool) {+ func triggerPasteLastTranscription(isAutorepeat: Bool) {Task { @MainActor [weak self] inguard let self = self else { return }// Holding the chord auto-repeats the key-down; act only on the initial press.diff --git a/Sources/Fluid/Services/MenuBarManager.swift b/Sources/Fluid/Services/MenuBarManager.swiftindex 3f97c20e..71a48bbf 100644--- a/Sources/Fluid/Services/MenuBarManager.swift+++ b/Sources/Fluid/Services/MenuBarManager.swift@@ -103,6 +103,11 @@ final class MenuBarManager: NSObject, ObservableObject, NSMenuDelegate {}.store(in: &self.cancellables)+ NotificationCenter.default.addObserver(forName: .fluidPasteNotLanded, object: nil, queue: .main) { [weak self] note in+ guard let transcript = note.userInfo?["transcript"] as? String else { return }+ Task { @MainActor [weak self] in self?.showPasteNotLandedFailure(transcript: transcript) }+ }+// Subscribe to recording state changesasrService.$isRunning.receive(on: DispatchQueue.main)@@ -291,6 +296,15 @@ final class MenuBarManager: NSObject, ObservableObject, NSMenuDelegate {}}+ /// A verified non-landing paste re-presents the overlay in its failure+ /// state so the transcript can be copied.+ func showPasteNotLandedFailure(transcript: String) {+ guard !self.overlayVisible, !self.isProcessingActive, self.asrService?.isRunning != true else { return }+ self.showRecordingOverlayImmediately()+ NotchContentState.shared.recordTextDeliveryFailure(.pasteNotLanded, transcript: transcript)+ self.finishProcessingKeepingOverlayVisible()+ }+func showRecordingOverlayImmediately() {AutomaticDictionaryCorrectionTracker.shared.cancel()diff --git a/Sources/Fluid/Services/PasteDeliveryCoordinator.swift b/Sources/Fluid/Services/PasteDeliveryCoordinator.swiftindex 681e034d..70a2b971 100644--- a/Sources/Fluid/Services/PasteDeliveryCoordinator.swift+++ b/Sources/Fluid/Services/PasteDeliveryCoordinator.swift@@ -12,6 +12,7 @@ enum TextDeliveryFailure: String, Equatable {case targetUnavailable = "target_unavailable"case targetRestoreFailed = "target_restore_failed"case noEditableTarget = "no_editable_target"+ case pasteNotLanded = "paste_not_landed"var userFacingMessage: String? {switch self {@@ -19,6 +20,8 @@ enum TextDeliveryFailure: String, Equatable {"Enable Accessibility to insert text"case .noEditableTarget:"Not in a text field"+ case .pasteNotLanded:+ "Text was not inserted"case .emptyText, .clipboardSnapshotFailed, .clipboardWriteFailed,.pasteCommandFailed, .targetUnavailable, .targetRestoreFailed:nildiff --git a/Sources/Fluid/Services/PasteVerifier.swift b/Sources/Fluid/Services/PasteVerifier.swiftnew file mode 100644index 00000000..70d6fc67--- /dev/null+++ b/Sources/Fluid/Services/PasteVerifier.swift@@ -0,0 +1,160 @@+import AppKit+import ApplicationServices+import Foundation++/// Reads the focused element back after a paste to learn whether the text+/// landed. `notLanded` is returned only when the same element, its value,+/// its character count and its caret all stayed unchanged across two reads.+/// Every other situation is `unknown`, and the caller stays silent.+enum PasteVerifier {+ struct Snapshot {+ let element: AXUIElement+ let pid: pid_t+ let role: String+ let value: String?+ let characterCount: Int?+ let caret: CFRange?++ var summary: String {+ "role=\(self.role) valueLen=\(self.value.map { String($0.count) } ?? "nil") " ++ "chars=\(self.characterCount.map(String.init) ?? "nil") " ++ "caret=\(self.caret.map { "\($0.location)+\($0.length)" } ?? "nil")"+ }+ }++ enum Verdict: Equatable {+ case confirmed(method: String)+ case notLanded(reason: String)+ case unknown(reason: String)++ var logDescription: String {+ switch self {+ case let .confirmed(method): "confirmed method=\(method)"+ case let .notLanded(reason): "notLanded reason=\(reason)"+ case let .unknown(reason): "unknown reason=\(reason)"+ }+ }+ }++ /// Value reads are skipped above this size; count and caret still work.+ private static let maxReadableCharacters = 60_000++ nonisolated static func capture() -> Snapshot? {+ guard AXIsProcessTrusted() else { return nil }+ var focusedRef: CFTypeRef?+ let result = AXUIElementCopyAttributeValue(+ AXUIElementCreateSystemWide(),+ kAXFocusedUIElementAttribute as CFString,+ &focusedRef+ )+ guard result == .success, let focusedRef, CFGetTypeID(focusedRef) == AXUIElementGetTypeID() else { return nil }+ let element = unsafeBitCast(focusedRef, to: AXUIElement.self)+ var pid: pid_t = 0+ AXUIElementGetPid(element, &pid)+ let role = self.string(element, kAXRoleAttribute as CFString) ?? "unknown"+ let count = self.number(element, kAXNumberOfCharactersAttribute as CFString)+ let value: String? = (count ?? 0) <= self.maxReadableCharacters+ ? self.string(element, kAXValueAttribute as CFString)+ : nil+ return Snapshot(+ element: element,+ pid: pid,+ role: role,+ value: value,+ characterCount: count,+ caret: self.range(element, kAXSelectedTextRangeAttribute as CFString)+ )+ }++ /// Call off the main thread after the paste command was posted.+ nonisolated static func verify(before: Snapshot, pastedText: String) async -> Verdict {+ let needle = self.normalize(pastedText)+ guard !needle.isEmpty else { return .unknown(reason: "empty_text") }+ guard before.value != nil || before.characterCount != nil || before.caret != nil else {+ return .unknown(reason: "before_unreadable")+ }++ try? await Task.sleep(nanoseconds: 150_000_000)+ guard let first = self.capture() else { return .unknown(reason: "after_unreadable") }+ guard CFEqual(first.element, before.element) else { return .unknown(reason: "focus_moved") }++ if let verdict = self.confirmation(before: before, after: first, needle: needle) { return verdict }++ // Nothing changed yet. Give slow apps a second chance before deciding.+ try? await Task.sleep(nanoseconds: 350_000_000)+ guard let second = self.capture(), CFEqual(second.element, before.element) else {+ return .unknown(reason: "focus_moved_late")+ }+ if let verdict = self.confirmation(before: before, after: second, needle: needle) { return verdict }++ let valueKnown = before.value != nil && second.value != nil+ let countKnown = before.characterCount != nil && second.characterCount != nil+ let caretKnown = before.caret != nil && second.caret != nil+ guard valueKnown, countKnown, caretKnown else {+ return .unknown(reason: "signals_incomplete value=\(valueKnown) count=\(countKnown) caret=\(caretKnown)")+ }+ guard before.value == second.value,+ before.characterCount == second.characterCount,+ before.caret?.location == second.caret?.location,+ before.caret?.length == second.caret?.length+ else { return .unknown(reason: "changed_without_text") }+ return .notLanded(reason: "value_count_caret_unchanged")+ }++ private nonisolated static func confirmation(before: Snapshot, after: Snapshot, needle: String) -> Verdict? {+ if let afterValue = after.value {+ let beforeCount = before.value.map { self.occurrences(of: needle, in: self.normalize($0)) } ?? 0+ if self.occurrences(of: needle, in: self.normalize(afterValue)) > beforeCount {+ return .confirmed(method: "value")+ }+ }+ if let beforeCount = before.characterCount, let afterCount = after.characterCount,+ afterCount - beforeCount == needle.count || afterCount - beforeCount == needle.count + 1+ {+ return .confirmed(method: "count")+ }+ if let beforeCaret = before.caret, let afterCaret = after.caret,+ afterCaret.location - beforeCaret.location - beforeCaret.length == needle.count+ {+ return .confirmed(method: "caret")+ }+ return nil+ }++ private nonisolated static func normalize(_ text: String) -> String {+ text.replacingOccurrences(of: "\r\n", with: "\n").trimmingCharacters(in: .whitespacesAndNewlines)+ }++ private nonisolated static func occurrences(of needle: String, in haystack: String) -> Int {+ guard !needle.isEmpty else { return 0 }+ return haystack.components(separatedBy: needle).count - 1+ }++ private nonisolated static func string(_ element: AXUIElement, _ attribute: CFString) -> String? {+ var ref: CFTypeRef?+ guard AXUIElementCopyAttributeValue(element, attribute, &ref) == .success else { return nil }+ return ref as? String+ }++ private nonisolated static func number(_ element: AXUIElement, _ attribute: CFString) -> Int? {+ var ref: CFTypeRef?+ guard AXUIElementCopyAttributeValue(element, attribute, &ref) == .success else { return nil }+ return (ref as? NSNumber)?.intValue+ }++ private nonisolated static func range(_ element: AXUIElement, _ attribute: CFString) -> CFRange? {+ var ref: CFTypeRef?+ guard AXUIElementCopyAttributeValue(element, attribute, &ref) == .success, let ref,+ CFGetTypeID(ref) == AXValueGetTypeID()+ else { return nil }+ var range = CFRange()+ guard AXValueGetValue(unsafeBitCast(ref, to: AXValue.self), .cfRange, &range) else { return nil }+ return range+ }+}++extension Notification.Name {+ /// Posted on the main queue with `userInfo["transcript"]` when a paste+ /// was verified to not land.+ static let fluidPasteNotLanded = Notification.Name("com.FluidApp.pasteNotLanded")+}diff --git a/Sources/Fluid/Services/TypingService.swift b/Sources/Fluid/Services/TypingService.swiftindex 42dd4ed3..6bbc8fa6 100644--- a/Sources/Fluid/Services/TypingService.swift+++ b/Sources/Fluid/Services/TypingService.swift@@ -524,6 +524,7 @@ final class TypingService {return result}+ let verificationBefore = PasteVerifier.capture()let usesClipboard = mode == .reliablePaste ||self.ghosttyTargetPID(preferredTargetPID: preferredTargetPID) != nillet result: TextDeliveryResult@@ -562,6 +563,9 @@ final class TypingService {toggleStopRequestedAt: toggleStopRequestedAt,completedAt: completedAt)+ if result == .commandPosted, deliveryPath != .direct, let verificationBefore {+ self.verifyPasteLanded(text, before: verificationBefore)+ }// The caller starts correction tracking after completing delivery UI.return result}@@ -683,6 +687,25 @@ final class TypingService {)}+ /// Off-main read-back after a paste. Logs every verdict; only a certain+ /// `notLanded` reaches the UI.+ private func verifyPasteLanded(_ text: String, before: PasteVerifier.Snapshot) {+ Task.detached(priority: .utility) {+ let startedAt = ProcessInfo.processInfo.systemUptime+ let verdict = await PasteVerifier.verify(before: before, pastedText: text)+ let app = NSRunningApplication(processIdentifier: before.pid)?.bundleIdentifier ?? "pid\(before.pid)"+ DebugLogger.shared.info(+ "PASTE_VERIFY \(verdict.logDescription) app=\(app) before[\(before.summary)] " ++ "elapsedMs=\(Int(((ProcessInfo.processInfo.systemUptime - startedAt) * 1000).rounded()))",+ source: "TypingService"+ )+ guard case .notLanded = verdict else { return }+ await MainActor.run {+ NotificationCenter.default.post(name: .fluidPasteNotLanded, object: nil, userInfo: ["transcript": text])+ }+ }+ }+private static func analyticsOutcome(for result: TextDeliveryResult) -> AnalyticsInsertionOutcome {switch result {case .commandPosted:@@ -697,6 +720,7 @@ final class TypingService {case .targetUnavailable: .targetUnavailablecase .targetRestoreFailed: .targetRestoreFailedcase .noEditableTarget: .noEditableTarget+ case .pasteNotLanded: .pasteNotLanded}}}