Skip to content

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.swift
index 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.swift
index 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.swift
index 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] in
guard 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.swift
index 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 changes
asrService.$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.swift
index 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:
nil
diff --git a/Sources/Fluid/Services/PasteVerifier.swift b/Sources/Fluid/Services/PasteVerifier.swift
new file mode 100644
index 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.swift
index 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) != nil
let 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: .targetUnavailable
case .targetRestoreFailed: .targetRestoreFailed
case .noEditableTarget: .noEditableTarget
+ case .pasteNotLanded: .pasteNotLanded
}
}
}