From ddcb7c17ad8c84b1c1661c0029f2a3553ad230bd Mon Sep 17 00:00:00 2001 From: Ali Alavi Date: Wed, 18 Nov 2026 22:41:12 +0000 Subject: [PATCH] feat(v3.0): zero-spam Unicode typing, ClipboardGuard, dual typing modes & first-word drop fixes --- Info.plist | 2 +- src/AppDelegate.swift | 91 ++--- src/AudioRecorder.swift | 36 +- src/ClipboardGuard.swift | 133 +++++++ src/InputBoxManager.swift | 644 ++++++++++++++++------------------ src/SonioxClient.swift | 273 ++++++-------- src/SonioxSettings.swift | 82 ++++- src/StatusBarController.swift | 63 ++++ src/TextProcessor.swift | 284 ++++++++++----- 9 files changed, 942 insertions(+), 666 deletions(-) create mode 100644 src/ClipboardGuard.swift diff --git a/Info.plist b/Info.plist index a8897da..36c4239 100644 --- a/Info.plist +++ b/Info.plist @@ -19,7 +19,7 @@ CFBundlePackageType APPL CFBundleShortVersionString - 2.17 + 3.0 CFBundleVersion 1 LSMinimumSystemVersion diff --git a/src/AppDelegate.swift b/src/AppDelegate.swift index 24313d6..6936143 100644 --- a/src/AppDelegate.swift +++ b/src/AppDelegate.swift @@ -182,11 +182,9 @@ public final class AppDelegate: NSObject, NSApplicationDelegate { let processed = TextProcessor.shared.process(text: recoveredText) guard !processed.isEmpty else { return } HistoryManager.shared.addEntry(processed) - let pb = NSPasteboard.general - pb.clearContents() - pb.setString(processed, forType: .string) + ClipboardGuard.shared.commitFinalClipboardRecordIfDesired(text: processed, deliveryMode: .batchOnRelease) self.playSound(named: "Glass") - print("AppDelegate: ✅ Offline queued speech recovered and placed on clipboard & history!") + print("AppDelegate: ✅ Offline queued speech recovered and saved to history!") } PingMonitor.shared.start() @@ -273,24 +271,25 @@ public final class AppDelegate: NSObject, NSApplicationDelegate { lastVoiceDetectedTime = Date() hasSpokenInCurrentSession = false - // Switch PingMonitor to 1.0s active cadence while HUD is shown - PingMonitor.shared.setActiveRecordingMode(true) - - // Start Hands-free silence watchdog timer (checks every 250ms) - handsFreeSilenceTimer?.invalidate() - handsFreeSilenceTimer = Timer.scheduledTimer(withTimeInterval: 0.25, repeats: true) { [weak self] _ in - self?.checkHandsFreeSilence() - } - - // 1. Reset session state without stealing focus + // 1. Reset input state & spin up non-blocking session + microphone IMMEDIATELY (t ≈ 0ms, before UI/Menu/Sound!) InputBoxManager.shared.ensureFocusedInputBox() - // 2. Acquire pre-warmed / fast-connected WebSocket session let session = SonioxSessionPool.shared.acquireSession() session.setRecordingActive(true) self.activeSession = session - // Handle network degradation warning + do { + try audioRecorder.startRecording() + } catch { + print("Failed to start recording: \(error)") + PingMonitor.shared.setActiveRecordingMode(false) + activeSession?.abort() + activeSession = nil + HUDOverlayController.shared.show(state: .error(message: "MIC ERR")) + return + } + + // 2. Wire session callbacks session.onNetworkDegraded = { [weak self] degraded in guard let self = self, self.currentGeneration() == myGen else { return } self.isNetworkDegraded = degraded @@ -302,34 +301,15 @@ public final class AppDelegate: NSObject, NSApplicationDelegate { session.onEndTriggerDetected = { [weak self] in guard let self = self, self.currentGeneration() == myGen else { return } guard HotkeyManager.shared.currentMode != .pushToTalk else { return } - print("AppDelegate: In-flight end trigger ('and'/'تمام') detected! Stopping recording immediately...") + print("AppDelegate: In-flight end trigger ('تمام') detected! Stopping recording immediately...") self.stopRecording() } - // Stream live finalized tokens directly into input box word-by-word - session.onCommittedDelta = { [weak self] delta in + session.onLiveTranscriptUpdate = { [weak self] fullCandidate, confirmedPrefix in guard let self = self, self.currentGeneration() == myGen else { return } - self.hasSpokenInCurrentSession = true self.lastVoiceDetectedTime = Date() - - if HotkeyManager.shared.currentMode != .pushToTalk { - let deltaWords = delta.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } - if let lastWord = deltaWords.last.map({ InputBoxManager.stripPunctuation($0).lowercased() }) { - if lastWord == "and" || lastWord == "تمام" || lastWord == "end" { - print("AppDelegate: In-speech end trigger detected ('\(lastWord)'). Finalizing speech...") - DispatchQueue.main.async { - self.stopRecording() - } - return - } - } - } - - if SonioxSettings.shared.voiceCommands && VoiceCommandExecutor.shared.isSlashCommand(text: delta) { - return - } - InputBoxManager.shared.streamDelta(text: delta) + InputBoxManager.shared.updateLiveTranscript(fullCandidate: fullCandidate, confirmedPrefix: confirmedPrefix) } session.onPartialText = { [weak self] partial in @@ -341,25 +321,24 @@ public final class AppDelegate: NSObject, NSApplicationDelegate { } } - do { - try audioRecorder.startRecording() - statusBarController.updateIcon(state: .recording) - statusBarController.buildMenu(isRecording: true) - HUDOverlayController.shared.show( - state: .recording( - level: 0.05, - isLagging: false, - pingQuality: PingMonitor.shared.currentQuality - ) - ) - playStartSound() - } catch { - print("Failed to start recording: \(error)") - PingMonitor.shared.setActiveRecordingMode(false) - activeSession?.abort() - activeSession = nil - HUDOverlayController.shared.show(state: .error(message: "MIC ERR")) + // 3. Switch PingMonitor, Silence Watchdog, HUD, Status Bar & Chime (after mic is already capturing!) + PingMonitor.shared.setActiveRecordingMode(true) + + handsFreeSilenceTimer?.invalidate() + handsFreeSilenceTimer = Timer.scheduledTimer(withTimeInterval: 0.25, repeats: true) { [weak self] _ in + self?.checkHandsFreeSilence() } + + statusBarController.updateIcon(state: .recording) + statusBarController.buildMenu(isRecording: true) + HUDOverlayController.shared.show( + state: .recording( + level: 0.05, + isLagging: false, + pingQuality: PingMonitor.shared.currentQuality + ) + ) + playStartSound() } private func cancelShortTapRecording() { diff --git a/src/AudioRecorder.swift b/src/AudioRecorder.swift index 9af39ba..83da9ce 100644 --- a/src/AudioRecorder.swift +++ b/src/AudioRecorder.swift @@ -12,7 +12,7 @@ public final class AudioRecorder: NSObject, AVCaptureAudioDataOutputSampleBuffer private var pcmBuffer = Data() private let lock = NSLock() private let captureQueue = DispatchQueue(label: "com.soniox.audiocapture", qos: .userInteractive) - private let sessionQueue = DispatchQueue(label: "com.soniox.audiosession", qos: .userInitiated) + private let sessionQueue = DispatchQueue(label: "com.soniox.audiosession", qos: .userInteractive) // Pre-allocated reusable buffers to eliminate 50Hz per-frame heap allocations private var reusableSrcBuffer: AVAudioPCMBuffer? @@ -182,16 +182,31 @@ public final class AudioRecorder: NSObject, AVCaptureAudioDataOutputSampleBuffer guard let srcBuffer = reusableSrcBuffer else { return } srcBuffer.frameLength = requiredSrcCap - var lengthAtOffset = 0 - var totalLength = 0 - var dataPointer: UnsafeMutablePointer? + let bytesPerFrame = Int(srcFormat.streamDescription.pointee.mBytesPerFrame) + let totalBlockLen = CMBlockBufferGetDataLength(blockBuffer) + guard bytesPerFrame > 0, totalBlockLen > 0 else { return } - if CMBlockBufferGetDataPointer(blockBuffer, atOffset: 0, lengthAtOffsetOut: &lengthAtOffset, totalLengthOut: &totalLength, dataPointerOut: &dataPointer) == noErr, - let dataPtr = dataPointer { - if let floatData = srcBuffer.floatChannelData?[0] { - memcpy(floatData, dataPtr, min(totalLength, Int(srcBuffer.frameLength) * 4)) - } else if let int16Data = srcBuffer.int16ChannelData?[0] { - memcpy(int16Data, dataPtr, min(totalLength, Int(srcBuffer.frameLength) * 2)) + if srcFormat.isInterleaved { + let abl = srcBuffer.mutableAudioBufferList + if let dst = abl.pointee.mBuffers.mData { + let bytesToCopy = min(totalBlockLen, Int(requiredSrcCap) * bytesPerFrame) + guard CMBlockBufferCopyDataBytes(blockBuffer, atOffset: 0, dataLength: bytesToCopy, destination: dst) == kCMBlockBufferNoErr else { return } + abl.pointee.mBuffers.mDataByteSize = UInt32(bytesToCopy) + } + } else { + let chCount = Int(srcFormat.channelCount) + let planeBytes = Int(requiredSrcCap) * bytesPerFrame + for ch in 0..= totalBlockLen { break } + let copyLen = min(planeBytes, totalBlockLen - offset) + if let floatChannel = srcBuffer.floatChannelData?[ch] { + _ = CMBlockBufferCopyDataBytes(blockBuffer, atOffset: offset, dataLength: copyLen, destination: floatChannel) + } else if let int16Channel = srcBuffer.int16ChannelData?[ch] { + _ = CMBlockBufferCopyDataBytes(blockBuffer, atOffset: offset, dataLength: copyLen, destination: int16Channel) + } else if let int32Channel = srcBuffer.int32ChannelData?[ch] { + _ = CMBlockBufferCopyDataBytes(blockBuffer, atOffset: offset, dataLength: copyLen, destination: int32Channel) + } } } @@ -200,6 +215,7 @@ public final class AudioRecorder: NSObject, AVCaptureAudioDataOutputSampleBuffer reusableOutBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: max(outCapacity, 2048)) } guard let outBuffer = reusableOutBuffer else { return } + outBuffer.frameLength = 0 var error: NSError? var haveData = true diff --git a/src/ClipboardGuard.swift b/src/ClipboardGuard.swift new file mode 100644 index 0000000..bb11c05 --- /dev/null +++ b/src/ClipboardGuard.swift @@ -0,0 +1,133 @@ +import Cocoa + +/// Manages NSPasteboard writes with strict anti-spam guarantees: +/// - Never touches clipboard during live word-by-word typing. +/// - Writes at most ONCE per dictation when `.copyFinalOnce` is active. +/// - Supports `org.nspasteboard.TransientType` & `org.nspasteboard.AutoGeneratedType` +/// plus full multi-representation snapshot/restore when `.preserveOriginal` is active, +/// preventing pollution in Maccy, Raycast, Paste, Alfred, and LaunchBar. +public final class ClipboardGuard { + public static let shared = ClipboardGuard() + + private static let transientType = NSPasteboard.PasteboardType("org.nspasteboard.TransientType") + private static let autoGeneratedType = NSPasteboard.PasteboardType("org.nspasteboard.AutoGeneratedType") + + private struct SavedItem { + let representations: [(type: NSPasteboard.PasteboardType, data: Data)] + } + + private let lock = NSLock() + private var pendingRestoreWorkItem: DispatchWorkItem? + + private init() {} + + /// Snapshots all current items & types on NSPasteboard.general before a transient paste. + private func snapshotCurrentPasteboard() -> [SavedItem] { + let pb = NSPasteboard.general + guard let items = pb.pasteboardItems, !items.isEmpty else { return [] } + var saved: [SavedItem] = [] + for item in items { + var reps: [(NSPasteboard.PasteboardType, Data)] = [] + for type in item.types { + if type == Self.transientType || type == Self.autoGeneratedType { + continue + } + if let data = item.data(forType: type) { + reps.append((type, data)) + } + } + if !reps.isEmpty { + saved.append(SavedItem(representations: reps)) + } + } + return saved + } + + /// Restores previously saved items only if no external app modified the pasteboard in the meantime. + private func restorePasteboard(_ saved: [SavedItem], expectedChangeCount: Int) { + let pb = NSPasteboard.general + guard pb.changeCount == expectedChangeCount else { return } + pb.clearContents() + guard !saved.isEmpty else { return } + var restoredItems: [NSPasteboardItem] = [] + for s in saved { + let item = NSPasteboardItem() + for (type, data) in s.representations { + item.setData(data, forType: type) + } + restoredItems.append(item) + } + pb.writeObjects(restoredItems) + } + + /// Writes final dictation text to clipboard at most ONCE according to user's ClipboardBehavior, + /// when text has already been typed via direct Unicode keystrokes (Live Word-by-Word mode). + public func commitFinalClipboardRecordIfDesired(text: String, deliveryMode: TypingDeliveryMode) { + let clean = text.trimmingCharacters(in: .whitespacesAndNewlines) + guard !clean.isEmpty else { return } + + let behavior = SonioxSettings.shared.clipboardBehavior + switch behavior { + case .copyFinalOnce: + lock.lock() + pendingRestoreWorkItem?.cancel() + pendingRestoreWorkItem = nil + lock.unlock() + let pb = NSPasteboard.general + pb.clearContents() + pb.setString(clean, forType: .string) + + case .preserveOriginal: + // Zero clipboard touches in live typing + preserve mode! + break + + case .copyInBatchOnly: + if deliveryMode == .batchOnRelease { + lock.lock() + pendingRestoreWorkItem?.cancel() + pendingRestoreWorkItem = nil + lock.unlock() + let pb = NSPasteboard.general + pb.clearContents() + pb.setString(clean, forType: .string) + } + } + } + + /// Prepares NSPasteboard for a single atomic Cmd+V paste (used in Batch Mode), + /// respecting the configured ClipboardBehavior. + public func writeForAtomicPaste(textToPaste: String, cleanFinalText: String) { + lock.lock() + pendingRestoreWorkItem?.cancel() + pendingRestoreWorkItem = nil + lock.unlock() + + let pb = NSPasteboard.general + let behavior = SonioxSettings.shared.clipboardBehavior + + switch behavior { + case .copyFinalOnce, .copyInBatchOnly: + // Write ONCE so changeCount increments only 1 time per dictation! + pb.clearContents() + pb.setString(textToPaste, forType: .string) + + case .preserveOriginal: + let snapshot = snapshotCurrentPasteboard() + pb.clearContents() + let item = NSPasteboardItem() + item.setString(textToPaste, forType: .string) + item.setData(Data(), forType: Self.transientType) + item.setData(Data(), forType: Self.autoGeneratedType) + pb.writeObjects([item]) + let expectedCount = pb.changeCount + + let work = DispatchWorkItem { [weak self] in + self?.restorePasteboard(snapshot, expectedChangeCount: expectedCount) + } + lock.lock() + pendingRestoreWorkItem = work + lock.unlock() + DispatchQueue.main.asyncAfter(deadline: .now() + 0.14, execute: work) + } + } +} diff --git a/src/InputBoxManager.swift b/src/InputBoxManager.swift index c7ac11a..b7c411a 100644 --- a/src/InputBoxManager.swift +++ b/src/InputBoxManager.swift @@ -1,22 +1,39 @@ import Cocoa import ApplicationServices +/// Zero-Spam Production Text Injection Engine (v3.0): +/// - Live Word-by-Word Mode: Injects characters directly via Quartz Unicode `CGEvent` (`keyboardSetUnicodeString`) +/// with clean modifier flags (`flags = []`), touching `NSPasteboard.general` **0 times** while speaking! +/// - Supports Provisional Live Words + Scalar-Safe Longest-Common-Prefix (LCP) Tail Rewrite so unfinalized words +/// appear immediately and smoothly transform into the exact final polished sentence when speech finishes. +/// - Batch Mode: Inserts the entire polished sentence at once upon key release, touching clipboard at most 1 time +/// (or 0 permanent times when `ClipboardBehavior.preserveOriginal` is selected). public final class InputBoxManager { public static let shared = InputBoxManager() private let lock = NSLock() - private var accumulatedStreamedText: String = "" - private var pendingPrefixBuffer: String = "" - private var isPrefixResolved: Bool = false - private var needsNewlineBeforeNextDelta: Bool = false private var sessionGeneration: UInt64 = 0 - private var clipboardRestoreWorkItem: DispatchWorkItem? + private var hasInjectedAnyLiveText: Bool = false + + // Accessed exclusively on serial `pasteQueue` (or reset via generation check) + private var displayedCharacters: [Character] = [] + private var lastBackspaceRewriteTime: TimeInterval = 0 + private var isExecutiveSlashSuppressed: Bool = false + private let pasteQueue = DispatchQueue(label: "com.soniox.pasteQueue", qos: .userInteractive) private static let punctRegex: NSRegularExpression = { return try! NSRegularExpression(pattern: #"[.,!?:;،؛؟"'()\[\]{}«»–—\-…]"#, options: []) }() + // Combining marks / zero-width joiners stripped ONLY during provisional live preview so + // `1 Swift Character == 1 Backspace (kVK_Delete)` holds across 100% of macOS apps (AppKit, Chrome, Electron, Terminal). + private static let provisionalUnsafeScalars: CharacterSet = { + var set = CharacterSet.nonBaseCharacters + set.insert(charactersIn: "\u{200B}\u{200D}\u{FEFF}") + return set + }() + private init() {} public static func stripPunctuation(_ str: String) -> String { @@ -24,412 +41,375 @@ public final class InputBoxManager { return punctRegex.stringByReplacingMatches(in: str, options: [], range: range, withTemplate: "") } - /// Reset session state at the beginning of speech + /// Converts provisional text into a strictly 1-character-per-backspace single-line representation. + public static func makeBackspaceSafeProvisional(_ text: String) -> String { + if text.isEmpty { return "" } + var out = String.UnicodeScalarView() + out.reserveCapacity(text.unicodeScalars.count) + var prevWasSpace = false + for scalar in text.unicodeScalars { + if scalar == "\u{200C}" || scalar == "\n" || scalar == "\r" || scalar == "\t" || scalar == "\u{00A0}" { + if !prevWasSpace { + out.append(" ") + prevWasSpace = true + } + continue + } + if provisionalUnsafeScalars.contains(scalar) { + continue + } + let isSpace = (scalar == " ") + if isSpace && prevWasSpace { + continue + } + prevWasSpace = isSpace + out.append(scalar) + } + return String(out) + } + + /// Reset session state at the beginning of speech or on Escape cancel. public func resetSession() { lock.lock() sessionGeneration &+= 1 - accumulatedStreamedText = "" - pendingPrefixBuffer = "" - isPrefixResolved = false - needsNewlineBeforeNextDelta = false - clipboardRestoreWorkItem?.cancel() - clipboardRestoreWorkItem = nil + hasInjectedAnyLiveText = false + let gen = sessionGeneration lock.unlock() + + pasteQueue.async { [weak self] in + guard let self = self else { return } + self.lock.lock() + let current = self.sessionGeneration + self.lock.unlock() + if current == gen { + self.displayedCharacters.removeAll(keepingCapacity: true) + self.lastBackspaceRewriteTime = 0 + self.isExecutiveSlashSuppressed = false + } + } } - /// Returns true if any text has been streamed into the input box during this session + /// Returns true if any characters were typed live into the focused input box during this session. public var hasStreamedText: Bool { lock.lock() defer { lock.unlock() } - let s = accumulatedStreamedText.trimmingCharacters(in: .whitespacesAndNewlines) - let p = pendingPrefixBuffer.trimmingCharacters(in: .whitespacesAndNewlines) - return !s.isEmpty || !p.isEmpty + return hasInjectedAnyLiveText } - /// Prepares session state before recording starts. - /// STRICT RULE: Focus is 100% user-directed. Never steal focus to browser address bar or toolbar. + /// Prepares session state before recording starts without stealing focus or blocking on modal prompts. public func ensureFocusedInputBox() { resetSession() - - let promptKey = kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String - let isTrusted = AXIsProcessTrustedWithOptions([promptKey: true] as CFDictionary) - guard isTrusted else { - print("InputBoxManager: Accessibility not trusted.") - return + if !AXIsProcessTrusted() { + print("InputBoxManager: Accessibility permission not yet granted (Unicode typing / paste requires Accessibility).") } } - /// Streams word-by-word delta text directly into the focused input box in real time - public func streamDelta(text: String) { - guard !text.isEmpty else { return } + /// Updates live simultaneous typing in `.liveWordByWord` mode with ZERO clipboard usage. + /// - Parameters: + /// - fullCandidate: Confirmed tokens + current unfinalized hypothesis. + /// - confirmedPrefix: Strictly finalized (`is_final == true`) tokens only. + public func updateLiveTranscript(fullCandidate: String, confirmedPrefix: String) { + guard SonioxSettings.shared.typingDeliveryMode == .liveWordByWord else { + return + } - // Suppress trailing end triggers ("and", "تمام", "end") ONLY in hands-free/toggle mode, never in Push-To-Talk - if HotkeyManager.shared.currentMode != .pushToTalk { - let triggerWords = text.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } - if let lastRaw = triggerWords.last { - let last = InputBoxManager.stripPunctuation(lastRaw).lowercased() - if last == "and" || last == "تمام" || last == "end" { - if triggerWords.count <= 1 { - return + let engineMode = SonioxSettings.shared.liveStreamEngineMode + let rawSource: String + switch engineMode { + case .provisionalRewrite: + rawSource = fullCandidate + case .confirmedFinalsOnly: + // Hold back the last unfinished compound number/punctuation word until next confirmed word arrives + rawSource = Self.confirmedStableSlice(from: confirmedPrefix) + } + + let trimmedCheck = fullCandidate.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmedCheck.isEmpty else { return } + + // Check Executive Slash Command holdback so "/chrome" or "اسلش چپ" is NEVER typed into the input box! + if SonioxSettings.shared.voiceCommands && !BotCommandProcessor.isBotCommand(text: trimmedCheck) { + let words = trimmedCheck.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } + if let first = words.first { + let cleanFirst = first.lowercased() + let slashTriggers = ["اسلش", "اصلش", "slash", "slsh", "/", "\\"] + let startsSlash = slashTriggers.contains(where: { cleanFirst.hasPrefix($0) }) + if startsSlash && words.count < 2 { + // Wait for 2nd word before deciding whether it's an executive command or normal text + return + } + if VoiceCommandExecutor.shared.isSlashCommand(text: trimmedCheck) { + lock.lock() + let expectedGen = sessionGeneration + lock.unlock() + pasteQueue.async { [weak self] in + guard let self = self else { return } + self.lock.lock() + let valid = (self.sessionGeneration == expectedGen) + self.lock.unlock() + guard valid else { return } + if !self.displayedCharacters.isEmpty { + self.postBackspaces(self.displayedCharacters.count) + self.displayedCharacters.removeAll() + } + self.isExecutiveSlashSuppressed = true } - let textWithoutEnd = triggerWords.dropLast().joined(separator: " ") + " " - streamDelta(text: textWithoutEnd) return } } } - // Apply lightweight inline formatting (domain vocabulary, voice punctuation, digits) so streamed words match final text - let normalizedDelta = TextProcessor.shared.processLiveChunk(text) + guard !rawSource.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return } + let formattedPreview = TextProcessor.shared.processLivePreview(rawSource) + let safeProvisional = Self.makeBackspaceSafeProvisional(formattedPreview) + guard !safeProvisional.isEmpty else { return } lock.lock() let expectedGen = sessionGeneration - if isPrefixResolved { - var textToPaste = normalizedDelta - if needsNewlineBeforeNextDelta { - needsNewlineBeforeNextDelta = false - let trimmed = normalizedDelta.trimmingCharacters(in: .whitespacesAndNewlines) - if !trimmed.isEmpty { - textToPaste = "\n" + trimmed - } - } - accumulatedStreamedText += textToPaste - lock.unlock() + lock.unlock() + + pasteQueue.async { [weak self] in + guard let self = self else { return } + self.lock.lock() + let valid = (self.sessionGeneration == expectedGen) + self.lock.unlock() + guard valid, !self.isExecutiveSlashSuppressed else { return } - pasteQueue.async { [weak self] in - guard let self = self else { return } - self.lock.lock() - let valid = (self.sessionGeneration == expectedGen) - self.lock.unlock() - guard valid else { return } - - self.pasteSynchronously(textToPaste) + let newChars = Array(safeProvisional) + if newChars == self.displayedCharacters { + return } - return - } - - // Not resolved yet: buffer to check if speech starts with a slash command - pendingPrefixBuffer += normalizedDelta - let trimmed = pendingPrefixBuffer.trimmingCharacters(in: .whitespacesAndNewlines) - let words = trimmed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } - - guard let firstWord = words.first else { - lock.unlock() - return - } - - let slashTriggers = ["اسلش", "اصلش", "slash", "/", "\\"] - let isSlashPrefix = slashTriggers.contains { firstWord.lowercased().hasPrefix($0) } - - if !isSlashPrefix { - // Normal speech: flush buffer immediately and continue normal streaming! - isPrefixResolved = true - let toFlush = pendingPrefixBuffer - pendingPrefixBuffer = "" - accumulatedStreamedText += toFlush - lock.unlock() - pasteQueue.async { [weak self] in - guard let self = self else { return } - self.lock.lock() - let valid = (self.sessionGeneration == expectedGen) - self.lock.unlock() - guard valid else { return } - - self.pasteSynchronously(toFlush) + var lcp = 0 + let limit = min(self.displayedCharacters.count, newChars.count) + while lcp < limit && self.displayedCharacters[lcp] == newChars[lcp] { + lcp += 1 } - return - } - - // Starts with slash trigger: check if it matches a Bot Command (/steer, /queue, /cancel) - if let botRes = BotCommandProcessor.parse(text: trimmed) { - isPrefixResolved = true - var textToPaste = botRes.command - if !botRes.body.isEmpty { - textToPaste += "\n" + botRes.body - needsNewlineBeforeNextDelta = false - } else { - needsNewlineBeforeNextDelta = true + + let eraseCount = self.displayedCharacters.count - lcp + if eraseCount > 0 { + // Throttle mid-speech backspace rewrites (~160ms) to avoid sub-syllable flicker while typing forward at 0ms! + let now = Date().timeIntervalSince1970 + if (now - self.lastBackspaceRewriteTime) < 0.16 { + return + } + self.lastBackspaceRewriteTime = now + self.postBackspaces(eraseCount) } - pendingPrefixBuffer = "" - accumulatedStreamedText = textToPaste - lock.unlock() + if lcp < newChars.count { + let deltaStr = String(newChars[lcp...]) + self.typeUnicodeSynchronously(deltaStr) + } - pasteQueue.async { [weak self] in - guard let self = self else { return } + self.displayedCharacters = newChars + if !newChars.isEmpty { self.lock.lock() - let valid = (self.sessionGeneration == expectedGen) + if self.sessionGeneration == expectedGen { + self.hasInjectedAnyLiveText = true + } self.lock.unlock() - guard valid else { return } - - self.pasteSynchronously(textToPaste) } - return } - - // If 2 words have accumulated and it's NOT a bot command: - if words.count >= 2 { - isPrefixResolved = true - // If it's an executive voice command, do NOT stream it to the input box! - if SonioxSettings.shared.voiceCommands && VoiceCommandExecutor.shared.isSlashCommand(text: trimmed) { - pendingPrefixBuffer = "" - lock.unlock() - return - } - - // Otherwise, it was just regular speech starting with "اسلش..." - let toFlush = pendingPrefixBuffer - pendingPrefixBuffer = "" - accumulatedStreamedText += toFlush - lock.unlock() - - pasteQueue.async { [weak self] in - guard let self = self else { return } - self.lock.lock() - let valid = (self.sessionGeneration == expectedGen) - self.lock.unlock() - guard valid else { return } - - self.pasteSynchronously(toFlush) + } + + /// Legacy delta entry point kept for compatibility. + public func streamDelta(text: String) { + // Handled cleanly via `updateLiveTranscript(fullCandidate:confirmedPrefix:)`. + } + + /// Holds back the trailing word in `.confirmedFinalsOnly` mode if it could be the first half of a + /// compound Persian number ("بیست" + "و پنج") or multi-word punctuation ("علامت" + "سوال"). + private static func confirmedStableSlice(from confirmed: String) -> String { + let trimmed = confirmed.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return "" } + let words = trimmed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } + let holdbackTriggers: Set = [ + "بیست", "سی", "چهل", "پنجاه", "شصت", "هفتاد", "هشتاد", "نود", + "صد", "دویست", "سیصد", "چهارصد", "پانصد", "ششصد", "هفتصد", "هشتصد", "نهصد", + "علامت", "نقطه", "خط", "سطر", "سر", "دو", "سه", "گیومه", "پرانتز", + "question", "exclamation", "semi", "full", "new", "enter", "open", "close" + ] + if let last = words.last { + let cleanLast = stripPunctuation(last).lowercased() + if holdbackTriggers.contains(cleanLast) { + if words.count <= 1 { return "" } + return words.dropLast().joined(separator: " ") + " " } - return } - - lock.unlock() + return confirmed } - /// Commits the final speech result: ensures 100% complete text in input box & clipboard without ANY duplication + /// Commits the final speech result: + /// - In Live Word-by-Word mode: smoothly rewrites only the differing tail from `displayedCharacters` to `finalOutput` + /// using pure Unicode keystrokes (0 `Cmd+V`), then copies full text ONCE to clipboard if configured. + /// - In Batch mode: inserts full polished text atomically in one shot, writing clipboard at most ONCE (or restoring original). public func commitFinalText(fullText: String, addTrailingSpace: Bool) { let trimmed = fullText.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return } - - let textWithTrailing = addTrailingSpace ? (trimmed + " ") : trimmed + let deliveryMode = SonioxSettings.shared.typingDeliveryMode lock.lock() let expectedGen = sessionGeneration - // Flush any pending buffer if recording ended before prefix resolution - if !isPrefixResolved && !pendingPrefixBuffer.isEmpty { - let pending = pendingPrefixBuffer - pendingPrefixBuffer = "" - if let botRes = BotCommandProcessor.parse(text: pending) { - accumulatedStreamedText = botRes.formattedText - } else if !(SonioxSettings.shared.voiceCommands && VoiceCommandExecutor.shared.isSlashCommand(text: pending)) { - accumulatedStreamedText += pending - } - } - let rawStreamed = accumulatedStreamedText - accumulatedStreamedText = "" lock.unlock() - // CRITICAL: Process the streamed text through the EXACT same TextProcessor pipeline as fullText! - // This guarantees that numbers (۱ -> 1), ellipses (... -> . . .), and punctuation tokens have identical word counts & tokens! - let processedStreamed = rawStreamed.isEmpty ? "" : TextProcessor.shared.process(text: rawStreamed) - let cleanStreamed = processedStreamed.trimmingCharacters(in: .whitespacesAndNewlines) - let streamedEndedWithSpace = rawStreamed.unicodeScalars.last.map { CharacterSet.whitespacesAndNewlines.contains($0) } ?? false - pasteQueue.async { [weak self] in guard let self = self else { return } self.lock.lock() let valid = (self.sessionGeneration == expectedGen) + self.hasInjectedAnyLiveText = false self.lock.unlock() guard valid else { return } - let restoreClipboardFullText = { [weak self] in - guard let self = self else { return } - let work = DispatchWorkItem { [weak self] in - guard let self = self else { return } - self.lock.lock() - let stillValid = (self.sessionGeneration == expectedGen) - self.lock.unlock() - guard stillValid else { return } - let pb = NSPasteboard.general - pb.clearContents() - pb.setString(textWithTrailing, forType: .string) + guard !trimmed.isEmpty else { + // Speech resolved to empty (e.g. stripped trigger): erase any provisional characters cleanly + if !self.displayedCharacters.isEmpty { + self.postBackspaces(self.displayedCharacters.count) + self.displayedCharacters.removeAll() } - self.lock.lock() - self.clipboardRestoreWorkItem?.cancel() - self.clipboardRestoreWorkItem = work - self.lock.unlock() - DispatchQueue.main.asyncAfter(deadline: .now() + 0.30, execute: work) - } - - // Case 1: Nothing was streamed live -> Paste entire text - if cleanStreamed.isEmpty { - self.pasteSynchronously(textWithTrailing) - restoreClipboardFullText() return } - // Case 2: Exactly matches streamed text - if cleanStreamed == trimmed { - if addTrailingSpace && !streamedEndedWithSpace { - self.pasteSynchronously(" ") - } - restoreClipboardFullText() - return - } + let finalOutput = addTrailingSpace ? (trimmed + " ") : trimmed - // Case 3: Streamed prefix is exact prefix of trimmed final text - if trimmed.count > cleanStreamed.count && trimmed.hasPrefix(cleanStreamed) { - let rawSuffix = String(trimmed.dropFirst(cleanStreamed.count)) - let cleanSuffix = rawSuffix.trimmingCharacters(in: .whitespacesAndNewlines) - if !cleanSuffix.isEmpty { - let needsLeadingSpace = !streamedEndedWithSpace && (rawSuffix.first?.isWhitespace == true) - let suffixToPaste = (needsLeadingSpace ? " " : "") + cleanSuffix + (addTrailingSpace ? " " : "") - self.pasteSynchronously(suffixToPaste) - } else if addTrailingSpace && !streamedEndedWithSpace { - self.pasteSynchronously(" ") + // PATH A: Live text was already typed on screen -> Minimal LCP Tail Rewrite via Unicode Keystrokes (0 Cmd+V!) + if !self.displayedCharacters.isEmpty { + let finalChars = Array(finalOutput) + var lcp = 0 + let limit = min(self.displayedCharacters.count, finalChars.count) + while lcp < limit && self.displayedCharacters[lcp] == finalChars[lcp] { + lcp += 1 + } + + let eraseCount = self.displayedCharacters.count - lcp + if eraseCount > 0 { + self.postBackspaces(eraseCount) } - restoreClipboardFullText() + if lcp < finalChars.count { + let suffixToType = String(finalChars[lcp...]) + self.typeUnicodeSynchronously(suffixToType) + } + + self.displayedCharacters.removeAll(keepingCapacity: true) + self.lastBackspaceRewriteTime = 0 + self.isExecutiveSlashSuppressed = false + + // Record complete final text on clipboard at most ONCE (or 0 times if preserveOriginal) + ClipboardGuard.shared.commitFinalClipboardRecordIfDesired(text: trimmed, deliveryMode: .liveWordByWord) return } - // Case 4: Word-level Tail-Anchor Matching with 1-to-1 Aligned Index Mapping - let rawStreamedWords = cleanStreamed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } - let rawFinalWords = trimmed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } + // PATH B: Nothing was typed yet (Batch Mode, or short utterance before live threshold) + self.isExecutiveSlashSuppressed = false - let cleanWord: (String) -> String = { w in - let noZwnj = w.replacingOccurrences(of: "\u{200C}", with: "").replacingOccurrences(of: "\u{200D}", with: "") - return InputBoxManager.stripPunctuation(noZwnj).lowercased() + // If user is still physically holding a modifier key (e.g. Option), avoid Cmd+V modifier collision + // by injecting short/medium text via pure modifier-clean Unicode events! + if HotkeyManager.shared.isPhysicalKeyDown && finalOutput.count <= 240 { + self.typeUnicodeSynchronously(finalOutput) + ClipboardGuard.shared.commitFinalClipboardRecordIfDesired(text: trimmed, deliveryMode: deliveryMode) + return } - // Keep ONLY words that contain actual alphanumeric/Persian letters so standalone punctuation (".", "...") NEVER shifts indices! - let streamedPairs: [(raw: String, norm: String)] = rawStreamedWords.compactMap { w in - let nw = cleanWord(w) - return nw.isEmpty ? nil : (w, nw) - } - let finalPairs: [(raw: String, norm: String)] = rawFinalWords.compactMap { w in - let nw = cleanWord(w) - return nw.isEmpty ? nil : (w, nw) - } + // Atomic Batch Paste (writes NSPasteboard at most ONCE, or snapshots+restores with TransientType) + let horizontalSpaceSet = CharacterSet(charactersIn: " \t") + let hasLeadingSpace = finalOutput.unicodeScalars.first.map { horizontalSpaceSet.contains($0) } ?? false + let hasTrailingSpace = finalOutput.unicodeScalars.last.map { horizontalSpaceSet.contains($0) } ?? false + let core = finalOutput.trimmingCharacters(in: horizontalSpaceSet) - guard !finalPairs.isEmpty else { - restoreClipboardFullText() + if core.isEmpty { + if hasLeadingSpace || hasTrailingSpace { + self.typeUnicodeSynchronously(" ") + } return } - let wordsMatch: (String, String) -> Bool = { w1, w2 in - if w1 == w2 { return true } - if w1.count >= 2 && w2.count >= 2 { - if w1.hasPrefix(w2) || w2.hasPrefix(w1) { return true } - } - return false + if hasLeadingSpace { + self.typeUnicodeSynchronously(" ") } - var unstreamedPairIndex: Int? = nil + ClipboardGuard.shared.writeForAtomicPaste(textToPaste: core, cleanFinalText: trimmed) + self.postCleanCmdV() + usleep(25000) - // Strategy 4A: 3-word tail anchor - if streamedPairs.count >= 3 { - let a1 = streamedPairs[streamedPairs.count - 3].norm - let a2 = streamedPairs[streamedPairs.count - 2].norm - let a3 = streamedPairs[streamedPairs.count - 1].norm - for j in stride(from: finalPairs.count - 1, through: 2, by: -1) { - if wordsMatch(finalPairs[j].norm, a3) && wordsMatch(finalPairs[j - 1].norm, a2) && wordsMatch(finalPairs[j - 2].norm, a1) { - unstreamedPairIndex = j + 1 - break - } - } + if hasTrailingSpace { + self.typeUnicodeSynchronously(" ") } - - // Strategy 4B: 2-word tail anchor - if unstreamedPairIndex == nil && streamedPairs.count >= 2 { - let a1 = streamedPairs[streamedPairs.count - 2].norm - let a2 = streamedPairs[streamedPairs.count - 1].norm - for j in stride(from: finalPairs.count - 1, through: 1, by: -1) { - if wordsMatch(finalPairs[j].norm, a2) && wordsMatch(finalPairs[j - 1].norm, a1) { - unstreamedPairIndex = j + 1 - break + } + } + + /// Types arbitrary Unicode text (Persian, ZWNJ, English, Arabic, emoji, multiline) directly via Quartz CGEvent + /// with `flags = []` so held hardware modifiers (Option/Fn/Control) never corrupt output and NSPasteboard is untouched. + private func typeUnicodeSynchronously(_ text: String) { + guard !text.isEmpty else { return } + let src = CGEventSource(stateID: .privateState) + + let segments = text.components(separatedBy: "\n") + for (segIdx, segment) in segments.enumerated() { + if !segment.isEmpty { + let utf16 = Array(segment.utf16) + var idx = 0 + let maxChunk = 16 + while idx < utf16.count { + var end = min(idx + maxChunk, utf16.count) + // Never split a UTF-16 high/low surrogate pair across two CGEvents + if end < utf16.count && (0xD800...0xDBFF).contains(utf16[end - 1]) { + end -= 1 } - } - } - - // Strategy 4C: 1-word tail anchor - if unstreamedPairIndex == nil && !streamedPairs.isEmpty { - let a1 = streamedPairs[streamedPairs.count - 1].norm - let searchStart = max(0, finalPairs.count - max(15, streamedPairs.count)) - for j in stride(from: finalPairs.count - 1, through: searchStart, by: -1) { - if wordsMatch(finalPairs[j].norm, a1) { - unstreamedPairIndex = j + 1 - break + let slice = Array(utf16[idx.. 0 { - unstreamedPairIndex = prefixMatchCount - } } - // Guaranteed Safety Fallback: aligned 1-to-1 on content-bearing pairs - if unstreamedPairIndex == nil { - unstreamedPairIndex = min(streamedPairs.count, finalPairs.count) + if segIdx < segments.count - 1 { + // Emit Shift+Return so multiline blocks (/steer\n..., "خط بعد") insert a clean line break + // without prematurely submitting chat messages in Telegram, Slack, Hermes, or browsers! + postShiftReturn(src: src) + usleep(4000) } - - if let startIndex = unstreamedPairIndex { - if startIndex < finalPairs.count { - let remainingWords = finalPairs.dropFirst(startIndex).map { $0.raw } - let suffix = remainingWords.joined(separator: " ") - let leadingSpace = streamedEndedWithSpace ? "" : " " - let trailingSpace = addTrailingSpace ? " " : "" - let suffixToPaste = leadingSpace + suffix + trailingSpace - self.pasteSynchronously(suffixToPaste) - restoreClipboardFullText() - return - } else { - if addTrailingSpace && !streamedEndedWithSpace { - self.pasteSynchronously(" ") - } - restoreClipboardFullText() - return - } - } - restoreClipboardFullText() } } - /// Places core word(s) on NSPasteboard via Cmd+V, while injecting leading/trailing spaces - /// via native Space keystrokes so apps that `.trim()` pasted clipboard text (like Hermes Desktop) - /// never glue words together or double-space! - private func pasteSynchronously(_ text: String) { - guard !text.isEmpty else { return } - let horizontalSpaceSet = CharacterSet(charactersIn: " \t") - let hasLeadingSpace = text.unicodeScalars.first.map { horizontalSpaceSet.contains($0) } ?? false - let hasTrailingSpace = text.unicodeScalars.last.map { horizontalSpaceSet.contains($0) } ?? false - let core = text.trimmingCharacters(in: horizontalSpaceSet) - - if core.isEmpty { - if hasLeadingSpace || hasTrailingSpace { - postCleanSpace() - usleep(12000) + private func postBackspaces(_ count: Int) { + guard count > 0 else { return } + let src = CGEventSource(stateID: .privateState) + let deleteKeyCode: CGKeyCode = 0x33 // kVK_Delete + for i in 0.. Void)? public var onCommittedDelta: ((String) -> Void)? + public var onLiveTranscriptUpdate: ((String, String) -> Void)? public var onEndTriggerDetected: (() -> Void)? public var onFinalResult: ((Result) -> Void)? public var onConnectionStateChanged: ((Bool) -> Void)? @@ -211,9 +214,17 @@ public final class SonioxLiveSession { self.isConnected = true self.lastDataTime = Date() self.initialAudioBuffer.removeAll() + let hasBuffered = !self.currentSegmentAudioBuffer.isEmpty + if hasBuffered { + self.isFlushingReplayBuffer = true + } + let bufferedBytes = self.currentSegmentAudioBuffer.count self.lock.unlock() self.onConnectionStateChanged?(true) - print("SonioxLiveSession: Connected successfully (\(endpoint)).") + print("SonioxLiveSession: Connected successfully (\(endpoint)). Flushing \(bufferedBytes) bytes of initial audio...") + if hasBuffered { + self.flushReplayBufferToSocket(task: task, offset: 0) + } } else { if let error = error { print("SonioxLiveSession: Ping failed on \(endpoint):", error) @@ -269,13 +280,17 @@ public final class SonioxLiveSession { self.isConnected = true self.hasNetworkFailure = false self.lastDataTime = Date() - let bufferedChunks = self.initialAudioBuffer self.initialAudioBuffer.removeAll() + let hasBuffered = !self.currentSegmentAudioBuffer.isEmpty + if hasBuffered { + self.isFlushingReplayBuffer = true + } + let bufferedBytes = self.currentSegmentAudioBuffer.count self.lock.unlock() self.onConnectionStateChanged?(true) - print("SonioxLiveSession: ✅ Fallback endpoint connected! Flushing \(bufferedChunks.count) buffered chunks...") - for chunk in bufferedChunks { - newTask.send(.data(chunk)) { _ in } + print("SonioxLiveSession: ✅ Fallback endpoint connected! Flushing \(bufferedBytes) bytes of buffered speech...") + if hasBuffered { + self.flushReplayBufferToSocket(task: newTask, offset: 0) } } else { self.hasNetworkFailure = true @@ -436,15 +451,21 @@ public final class SonioxLiveSession { private func flushReplayBufferToSocket(task: URLSessionWebSocketTask, offset: Int) { lock.lock() - guard isConnected, !isClosed, !isAborted, !isFinalizing, webSocketTask === task else { + guard isConnected, !isClosed, !isAborted, (!isFinalizing || pendingFinalizeAfterFlush), webSocketTask === task else { isFlushingReplayBuffer = false + pendingFinalizeAfterFlush = false lock.unlock() return } let total = currentSegmentAudioBuffer.count if offset >= total { isFlushingReplayBuffer = false + let shouldSendFinalizeNow = pendingFinalizeAfterFlush + pendingFinalizeAfterFlush = false lock.unlock() + if shouldSendFinalizeNow { + sendFinalizeFramesOnTask(task) + } return } let chunkSize = 32000 // 1.0s chunk @@ -554,7 +575,11 @@ public final class SonioxLiveSession { } isFinalizing = true let connected = isConnected && !isReconnectingMidRecording + let flushing = isFlushingReplayBuffer let task = webSocketTask + if connected && flushing && task != nil { + pendingFinalizeAfterFlush = true + } lock.unlock() guard connected, let task = task else { @@ -563,42 +588,47 @@ public final class SonioxLiveSession { return } - print("SonioxLiveSession: Sending finalize packet...") - // 1. Send trailing 300ms (9600 bytes at 16kHz 16-bit PCM) silence frame - // so acoustic CTC model cleanly flushes and resolves trailing fast speech syllables - let silenceChunk = Data(count: 9600) - let silenceMsg = URLSessionWebSocketTask.Message.data(silenceChunk) - task.send(silenceMsg) { _ in } - - // 2. Send finalize JSON - let finalizeMsg = URLSessionWebSocketTask.Message.string("{\"type\": \"finalize\"}") - task.send(finalizeMsg) { [weak self] error in - if let error = error { - print("SonioxLiveSession: Error sending finalize:", error) - self?.lock.lock() - self?.hasNetworkFailure = true - self?.lock.unlock() - self?.completeWithCurrentText() - } + if flushing { + print("SonioxLiveSession: Waiting for initial/replay buffer flush to finish before sending finalize packet...") + } else { + sendFinalizeFramesOnTask(task) } - // 3. Send official "END" token for complete Soniox termination - let endMsg = URLSessionWebSocketTask.Message.string("END") - task.send(endMsg) { _ in } - - // Safety timeout fallback: allow up to 4.0s for STT inference & network transit - DispatchQueue.global().asyncAfter(deadline: .now() + 4.0) { [weak self] in + // Safety timeout fallback: allow up to 4.5s for STT inference & network transit + DispatchQueue.global().asyncAfter(deadline: .now() + 4.5) { [weak self] in guard let self = self else { return } self.lock.lock() let stillOpen = !self.isClosed && !self.isAborted self.lock.unlock() if stillOpen { - print("SonioxLiveSession: Finalize timeout (4.0s) reached — completing.") + print("SonioxLiveSession: Finalize timeout (4.5s) reached — completing.") self.completeWithCurrentText() } } } + private func sendFinalizeFramesOnTask(_ task: URLSessionWebSocketTask) { + print("SonioxLiveSession: Sending finalize packet...") + let silenceChunk = Data(count: 9600) + let silenceMsg = URLSessionWebSocketTask.Message.data(silenceChunk) + let finalizeMsg = URLSessionWebSocketTask.Message.string("{\"type\": \"finalize\"}") + let endMsg = URLSessionWebSocketTask.Message.string("END") + + task.send(silenceMsg) { [weak self] _ in + task.send(finalizeMsg) { [weak self] error in + if let error = error { + print("SonioxLiveSession: Error sending finalize:", error) + self?.lock.lock() + self?.hasNetworkFailure = true + self?.lock.unlock() + self?.completeWithCurrentText() + return + } + task.send(endMsg) { _ in } + } + } + } + private func startReceiving() { guard let task = webSocketTask else { return } task.receive { [weak self] result in @@ -725,15 +755,25 @@ public final class SonioxLiveSession { combined = archivedCommittedText + (cleanSeg.isEmpty ? "" : (" " + cleanSeg)) } - // Check for in-flight end trigger ("and", "تمام", "end") ONLY in hands-free/toggle mode and ONLY on finalized tokens! - // Never trigger auto-stop during Push-To-Talk while user is physically holding the hotkey! + let confirmedCombined: String + if archivedCommittedText.isEmpty { + confirmedCombined = fullCommitted + } else if fullCommitted.isEmpty { + confirmedCombined = archivedCommittedText + } else { + let cleanComm = fullCommitted.trimmingCharacters(in: .whitespaces) + confirmedCombined = archivedCommittedText + (cleanComm.isEmpty ? "" : (" " + cleanComm)) + } + + // Check for in-flight end trigger ("تمام") ONLY in hands-free/toggle mode and ONLY on finalized tokens! + // Never trigger auto-stop during Push-To-Talk, and NEVER trigger on common English words like "and" / "end"! var triggerDetected = false if HotkeyManager.shared.currentMode != .pushToTalk && currentNonFinalTokens.isEmpty && !newFinals.isEmpty { let trimmedCombined = combined.trimmingCharacters(in: .whitespacesAndNewlines) let currentWords = trimmedCombined.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } if let lastRaw = currentWords.last { let cleanLast = InputBoxManager.stripPunctuation(lastRaw).lowercased() - if cleanLast == "and" || cleanLast == "تمام" || cleanLast == "end" { + if cleanLast == "تمام" { triggerDetected = true } } @@ -749,42 +789,16 @@ public final class SonioxLiveSession { }() let isTerminatingMessage = gotFin || sessionEnded || sessionDone || isFinished || hasRawFinished let stillActivelyRecording = self.isRecordingActive && !self.isFinalizing - - // Emit live streaming deltas in real time as the user speaks! - // We stream completed words in `combined` with a 1-word acoustic lookahead holdback so every emitted chunk ends with a trailing space. - var deltaToEmit: String? = nil - if !triggerDetected && !isTerminatingMessage && !self.isFinalizing { - let rTrimmedCombined = combined.replacingOccurrences(of: #"\s+$"#, with: "", options: .regularExpression) - var stableCandidate = "" - if let lastSpaceRange = rTrimmedCombined.rangeOfCharacter(from: .whitespacesAndNewlines, options: .backwards) { - stableCandidate = String(rTrimmedCombined[.. streamedPrefix.count { - if stableCandidate.hasPrefix(streamedPrefix) { - let delta = String(stableCandidate.dropFirst(streamedPrefix.count)) - streamedPrefix = stableCandidate - deltaToEmit = delta - } else { - let streamedWordsCount = streamedPrefix.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }.count - let candidateWords = stableCandidate.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } - if candidateWords.count > streamedWordsCount { - let delta = candidateWords.dropFirst(streamedWordsCount).joined(separator: " ") + " " - streamedPrefix = stableCandidate - deltaToEmit = delta - } - } - } - } + let shouldEmitLiveUpdate = !triggerDetected && !isTerminatingMessage && !self.isFinalizing && !combined.isEmpty lock.unlock() if triggerDetected { DispatchQueue.main.async { [weak self] in self?.onEndTriggerDetected?() } - } else if let delta = deltaToEmit, !delta.isEmpty { + } else if shouldEmitLiveUpdate { DispatchQueue.main.async { [weak self] in - self?.onCommittedDelta?(delta) + self?.onLiveTranscriptUpdate?(combined, confirmedCombined) } } @@ -799,6 +813,9 @@ public final class SonioxLiveSession { print("SonioxLiveSession: Server ended WebSocket segment while user is still speaking — seamlessly rotating to fresh segment...") triggerMidRecordingReconnect(cleanArchive: true, reason: "Server ended WebSocket segment while recording is still active") } else { + lock.lock() + didReceiveTermination = true + lock.unlock() completeWithCurrentText() } } @@ -813,6 +830,9 @@ public final class SonioxLiveSession { if sessionEnded || sessionDone || isFinished || hasRawFinished { lock.lock() let stillActivelyRecording = self.isRecordingActive && !self.isFinalizing + if !stillActivelyRecording { + self.didReceiveTermination = true + } lock.unlock() if stillActivelyRecording { triggerMidRecordingReconnect(cleanArchive: true, reason: "Server session_done while recording is still active") @@ -847,8 +867,8 @@ public final class SonioxLiveSession { return } let tailCount = max(0, currentSegmentAudioBuffer.count - lastConfirmedWordAudioByteOffset) - let hadDrop = hasNetworkFailure || hasSilentStall || isReconnectingMidRecording || !isConnected - let needsTailRecovery = hadDrop && tailCount > 11200 + let hadDrop = hasNetworkFailure || hasSilentStall || isReconnectingMidRecording || !isConnected || (isFinalizing && !didReceiveTermination) + let needsTailRecovery = hadDrop && tailCount > 4800 isClosed = true isReconnectingMidRecording = false @@ -896,10 +916,12 @@ public final class SonioxLiveSession { isFinalizing = false isReconnectingMidRecording = false isFlushingReplayBuffer = false + pendingFinalizeAfterFlush = false initialAudioBuffer.removeAll() currentSegmentAudioBuffer.removeAll() onPartialText = nil onCommittedDelta = nil + onLiveTranscriptUpdate = nil onEndTriggerDetected = nil onFinalResult = nil onConnectionStateChanged = nil @@ -1363,44 +1385,19 @@ public final class SonioxLiveSession { let words = trimmed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty } if words.isEmpty { return "" } - func matches(_ regex: NSRegularExpression, in str: String) -> Bool { - let range = NSRange(location: 0, length: str.utf16.count) - return regex.firstMatch(in: str, options: [], range: range) != nil + // Strip ONLY pure single-phrase silence noise hallucinations — NEVER delete valid English words + // ("for", "from", "all", "no", "day", "you", etc.) inside mixed Persian/English developer speech! + let lowerNormalized = words.map { $0.lowercased().trimmingCharacters(in: punctCharSet) }.joined(separator: " ") + let pureSilenceArtifacts: Set = ["sex", "god loves mankind"] + if pureSilenceArtifacts.contains(lowerNormalized) { + return "" } - var faCount = 0 - var enCount = 0 - for w in words { - if matches(faRegex, in: w) { faCount += 1 } - if matches(enRegex, in: w) { enCount += 1 } - } - - let total = faCount + enCount - if total == 0 { return trimmed } - - let faRatio = Double(faCount) / Double(total) - var cleaned: [String] = [] - - let stopWords: Set = ["sex", "from", "no", "oh", "you", "all", "know", "that", "god", "loves", "men", "for", "day", "night", "mankind", "wanted", "moments"] - - if faRatio >= 0.25 { - for w in words { - if matches(enRegex, in: w) && !matches(faRegex, in: w) { - let cleanW = w.lowercased().trimmingCharacters(in: punctCharSet) - // Strip ONLY known acoustic noise hallucinations; preserve legitimate English technical terms (Soniox, Voice, Sync, Mac, Push, Talk, API, etc.) - if stopWords.contains(cleanW) { continue } - } - cleaned.append(w) - } - } else { - cleaned = words - } - - return cleaned.joined(separator: " ").trimmingCharacters(in: .whitespacesAndNewlines) + return words.joined(separator: " ").trimmingCharacters(in: .whitespacesAndNewlines) } } -// MARK: - Pre-warmed Session Pool +// MARK: - On-Demand Session Factory (Zero Idle Key Burn + Non-Blocking Acquisition) public final class SonioxSessionPool { public static let shared = SonioxSessionPool() @@ -1408,25 +1405,18 @@ public final class SonioxSessionPool { private var prewarmedSession: SonioxLiveSession? private var prewarmedSessionCreatedAt: Date = Date() private let lock = NSLock() - private var isPrewarming = false private init() { - prewarmNextSession() setupSleepWakeObservers() } private func setupSleepWakeObservers() { NSWorkspace.shared.notificationCenter.addObserver(forName: NSWorkspace.willSleepNotification, object: nil, queue: .main) { [weak self] _ in - print("SonioxSessionPool: Mac entering sleep. Discarding pre-warmed session.") self?.discardPrewarmedSession() } NSWorkspace.shared.notificationCenter.addObserver(forName: NSWorkspace.didWakeNotification, object: nil, queue: .main) { [weak self] _ in - print("SonioxSessionPool: Mac woke from sleep. Re-priming fresh session in 2.0s...") self?.discardPrewarmedSession() - DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { - self?.prewarmNextSession() - } } } @@ -1435,66 +1425,20 @@ public final class SonioxSessionPool { prewarmedSession?.stopKeepAliveHeartbeat() prewarmedSession?.abort() prewarmedSession = nil - isPrewarming = false lock.unlock() } public func prewarmNextSession() { - guard PingMonitor.shared.isPathSatisfied else { return } - lock.lock() - defer { lock.unlock() } - - if let existing = prewarmedSession, existing.isReady { - let age = Date().timeIntervalSince(prewarmedSessionCreatedAt) - if age < 45.0 { - return - } - } - - if isPrewarming { return } - isPrewarming = true - - prewarmedSession?.stopKeepAliveHeartbeat() - prewarmedSession?.abort() - prewarmedSession = nil - - DispatchQueue.global(qos: .userInitiated).async { [weak self] in - guard let self = self else { return } - let hints = SonioxSettings.shared.language.hints - let target = SonioxSettings.shared.targetLanguage.isEnabled ? SonioxSettings.shared.targetLanguage.rawValue : nil - let session = SonioxLiveSession(languageHints: hints, targetLanguage: target) - - session.onConnectionStateChanged = { [weak self, weak session] connected in - guard let self = self, let session = session else { return } - self.lock.lock() - defer { self.lock.unlock() } - if connected { - session.startKeepAliveHeartbeat() - self.prewarmedSession = session - self.prewarmedSessionCreatedAt = Date() - self.isPrewarming = false - print("SonioxSessionPool: Fresh prewarmed session connected & ready.") - } else { - self.isPrewarming = false - } - } - - DispatchQueue.global().asyncAfter(deadline: .now() + 12.0) { [weak self] in - guard let self = self else { return } - self.lock.lock() - if self.isPrewarming && self.prewarmedSession == nil { - self.isPrewarming = false - } - self.lock.unlock() - } - } + // Intentional no-op while idle: opening an idle WebSocket burns single-use KeyPool temp keys + // and risks half-open upstream timeouts. AudioRecorder captures from t=0ms into currentSegmentAudioBuffer, + // which flushes in strict FIFO order the instant the on-demand WebSocket connects! } public func reconnectAll() { discardPrewarmedSession() - prewarmNextSession() } + /// Non-blocking session creation (0ms main-thread wait!). public func acquireSession() -> SonioxLiveSession { lock.lock() let session = prewarmedSession @@ -1502,34 +1446,15 @@ public final class SonioxSessionPool { prewarmedSession = nil lock.unlock() - DispatchQueue.global(qos: .userInitiated).async { [weak self] in - self?.prewarmNextSession() - } - let age = Date().timeIntervalSince(createdAt) - if let session = session, session.isReady && age < 60.0 { + if let session = session, session.isReady && age < 12.0 { session.stopKeepAliveHeartbeat() - print("SonioxSessionPool: Acquired HOT prewarmed session (age: \(String(format: "%.1f", age))s, 0ms connect delay!)") return session } - // If prewarmed session is connecting or slightly aged, wait up to 0.4s for it before aborting - if let session = session, !session.isReady && age < 15.0 { - let tStart = Date() - while Date().timeIntervalSince(tStart) < 0.40 { - if session.isReady { - session.stopKeepAliveHeartbeat() - print("SonioxSessionPool: Acquired session after \(Int(Date().timeIntervalSince(tStart)*1000))ms connection wait.") - return session - } - usleep(25000) // 25ms - } - } - session?.stopKeepAliveHeartbeat() session?.abort() - print("SonioxSessionPool: Prewarmed session not ready/stale (age: \(String(format: "%.1f", age))s), creating immediate on-demand session.") let hints = SonioxSettings.shared.language.hints let target = SonioxSettings.shared.targetLanguage.isEnabled ? SonioxSettings.shared.targetLanguage.rawValue : nil return SonioxLiveSession(languageHints: hints, targetLanguage: target) diff --git a/src/SonioxSettings.swift b/src/SonioxSettings.swift index b81694f..491412d 100644 --- a/src/SonioxSettings.swift +++ b/src/SonioxSettings.swift @@ -120,6 +120,51 @@ public enum NumberFormatOption: String, CaseIterable { } } +public enum TypingDeliveryMode: String, CaseIterable { + case liveWordByWord = "liveWordByWord" + case batchOnRelease = "batchOnRelease" + + public var displayName: String { + switch self { + case .liveWordByWord: + return "⚡️ Live Word-by-Word (Simultaneous Typing)" + case .batchOnRelease: + return "📦 Full Sentence on Release (After Speaking)" + } + } +} + +public enum LiveStreamEngineMode: String, CaseIterable { + case provisionalRewrite = "provisionalRewrite" + case confirmedFinalsOnly = "confirmedFinalsOnly" + + public var displayName: String { + switch self { + case .provisionalRewrite: + return "✨ Instant Live Words + Auto-Polish on Finish (Recommended)" + case .confirmedFinalsOnly: + return "🔒 Confirmed Final Words Only (No Rewrite)" + } + } +} + +public enum ClipboardBehavior: String, CaseIterable { + case copyFinalOnce = "copyFinalOnce" + case preserveOriginal = "preserveOriginal" + case copyInBatchOnly = "copyInBatchOnly" + + public var displayName: String { + switch self { + case .copyFinalOnce: + return "📋 Copy Full Text Once at End (Default)" + case .preserveOriginal: + return "🛡️ Preserve Previous Clipboard (Zero History)" + case .copyInBatchOnly: + return "📦 Copy Only in Full-Sentence Mode" + } + } +} + public final class SonioxSettings { public static let shared = SonioxSettings() @@ -216,10 +261,40 @@ public final class SonioxSettings { public var liveStreamingInput: Bool { get { - return defaults.bool(forKey: "SonioxLiveStreamingInput") + return typingDeliveryMode == .liveWordByWord + } + set { + typingDeliveryMode = newValue ? .liveWordByWord : .batchOnRelease + } + } + + public var typingDeliveryMode: TypingDeliveryMode { + get { + let val = defaults.string(forKey: "SonioxTypingDeliveryMode") ?? TypingDeliveryMode.liveWordByWord.rawValue + return TypingDeliveryMode(rawValue: val) ?? .liveWordByWord + } + set { + defaults.set(newValue.rawValue, forKey: "SonioxTypingDeliveryMode") + } + } + + public var liveStreamEngineMode: LiveStreamEngineMode { + get { + let val = defaults.string(forKey: "SonioxLiveStreamEngineMode") ?? LiveStreamEngineMode.provisionalRewrite.rawValue + return LiveStreamEngineMode(rawValue: val) ?? .provisionalRewrite + } + set { + defaults.set(newValue.rawValue, forKey: "SonioxLiveStreamEngineMode") + } + } + + public var clipboardBehavior: ClipboardBehavior { + get { + let val = defaults.string(forKey: "SonioxClipboardBehavior") ?? ClipboardBehavior.copyFinalOnce.rawValue + return ClipboardBehavior(rawValue: val) ?? .copyFinalOnce } set { - defaults.set(newValue, forKey: "SonioxLiveStreamingInput") + defaults.set(newValue.rawValue, forKey: "SonioxClipboardBehavior") } } @@ -266,6 +341,9 @@ public final class SonioxSettings { defaults.removeObject(forKey: "SonioxDomainVocabulary") defaults.removeObject(forKey: "SonioxAddTrailingSpace") defaults.removeObject(forKey: "SonioxNormalizeText") + defaults.removeObject(forKey: "SonioxTypingDeliveryMode") + defaults.removeObject(forKey: "SonioxLiveStreamEngineMode") + defaults.removeObject(forKey: "SonioxClipboardBehavior") defaults.removeObject(forKey: "SonioxPlaySounds") defaults.removeObject(forKey: "SonioxLaunchAtLogin") defaults.removeObject(forKey: "SonioxPreferredAudioDevice") diff --git a/src/StatusBarController.swift b/src/StatusBarController.swift index bc754fc..5ae51eb 100644 --- a/src/StatusBarController.swift +++ b/src/StatusBarController.swift @@ -88,6 +88,34 @@ public final class StatusBarController: NSObject, NSMenuDelegate { modeMenuItem.submenu = modeMenu menu.addItem(modeMenuItem) + // 2.5. Typing Delivery Mode Submenu (Live Word-by-Word vs Full Sentence on Release) + let deliveryMenu = NSMenu() + for delivery in TypingDeliveryMode.allCases { + let item = NSMenuItem(title: delivery.displayName, action: #selector(selectTypingDeliveryAction(_:)), keyEquivalent: "") + item.target = self + item.representedObject = delivery + item.state = (SonioxSettings.shared.typingDeliveryMode == delivery) ? .on : .off + deliveryMenu.addItem(item) + } + let currentDelivery = SonioxSettings.shared.typingDeliveryMode + let deliveryShort = (currentDelivery == .liveWordByWord) ? "Word-by-Word" : "On Release" + let deliveryMenuItem = NSMenuItem(title: "✍️ Typing Mode (\(deliveryShort))", action: nil, keyEquivalent: "") + deliveryMenuItem.submenu = deliveryMenu + menu.addItem(deliveryMenuItem) + + // 2.6. Clipboard Behavior Submenu + let clipboardMenu = NSMenu() + for behavior in ClipboardBehavior.allCases { + let item = NSMenuItem(title: behavior.displayName, action: #selector(selectClipboardBehaviorAction(_:)), keyEquivalent: "") + item.target = self + item.representedObject = behavior + item.state = (SonioxSettings.shared.clipboardBehavior == behavior) ? .on : .off + clipboardMenu.addItem(item) + } + let clipboardMenuItem = NSMenuItem(title: "📋 Clipboard Behavior", action: nil, keyEquivalent: "") + clipboardMenuItem.submenu = clipboardMenu + menu.addItem(clipboardMenuItem) + // 3. Hotkey Preset Submenu let hotkeyMenu = NSMenu() for preset in HotkeyPreset.allCases { @@ -182,6 +210,20 @@ public final class StatusBarController: NSObject, NSMenuDelegate { // 8. Advanced Options Submenu let advancedMenu = NSMenu() + let streamEngineMenu = NSMenu() + for eng in LiveStreamEngineMode.allCases { + let item = NSMenuItem(title: eng.displayName, action: #selector(selectLiveStreamEngineAction(_:)), keyEquivalent: "") + item.target = self + item.representedObject = eng + item.state = (SonioxSettings.shared.liveStreamEngineMode == eng) ? .on : .off + streamEngineMenu.addItem(item) + } + let streamEngineMenuItem = NSMenuItem(title: "✨ Word-by-Word Stream Engine", action: nil, keyEquivalent: "") + streamEngineMenuItem.submenu = streamEngineMenu + advancedMenu.addItem(streamEngineMenuItem) + + advancedMenu.addItem(NSMenuItem.separator()) + let slashCmdItem = NSMenuItem(title: "⚡️ Executive Voice Slash Commands", action: #selector(toggleVoiceCommandsAction(_:)), keyEquivalent: "") slashCmdItem.target = self slashCmdItem.state = SonioxSettings.shared.voiceCommands ? .on : .off @@ -346,6 +388,27 @@ public final class StatusBarController: NSObject, NSMenuDelegate { } } + @objc private func selectTypingDeliveryAction(_ sender: NSMenuItem) { + if let delivery = sender.representedObject as? TypingDeliveryMode { + SonioxSettings.shared.typingDeliveryMode = delivery + buildMenu() + } + } + + @objc private func selectClipboardBehaviorAction(_ sender: NSMenuItem) { + if let behavior = sender.representedObject as? ClipboardBehavior { + SonioxSettings.shared.clipboardBehavior = behavior + buildMenu() + } + } + + @objc private func selectLiveStreamEngineAction(_ sender: NSMenuItem) { + if let eng = sender.representedObject as? LiveStreamEngineMode { + SonioxSettings.shared.liveStreamEngineMode = eng + buildMenu() + } + } + @objc private func selectHotkeyAction(_ sender: NSMenuItem) { if let preset = sender.representedObject as? HotkeyPreset { HotkeyManager.shared.currentPreset = preset diff --git a/src/TextProcessor.swift b/src/TextProcessor.swift index c1882b9..908cb1a 100644 --- a/src/TextProcessor.swift +++ b/src/TextProcessor.swift @@ -3,17 +3,62 @@ import Foundation public final class TextProcessor { public static let shared = TextProcessor() + // Only strip explicit stop triggers ("تمام", "پایان دیکته", "stop dictation") — NEVER strip "and" or "end" in normal speech! private static let trailingEndRegex: NSRegularExpression = { - return try! NSRegularExpression(pattern: #"[،,:\s]+(and|تمام|end)[.!?]?$"#, options: .caseInsensitive) + return try! NSRegularExpression(pattern: #"[،,:\s]+(تمام|پایان دیکته|stop dictation)[.!?؟]?$"#, options: .caseInsensitive) }() private static let singleEndRegex: NSRegularExpression = { - return try! NSRegularExpression(pattern: #"^(and|تمام|end)[.!?]?$"#, options: .caseInsensitive) + return try! NSRegularExpression(pattern: #"^(تمام|پایان دیکته|stop dictation)[.!?؟]?$"#, options: .caseInsensitive) + }() + + // Context-aware regexes (100% fixed-length ICU lookbehinds!) so content words + // ("نقطه ضعف", "این نقطه", "در خط بعد", "دکمه اینتر", "period of") are NEVER corrupted, + // while words ending in similar letters ("پایین نقطه" -> "پایین.") STILL convert properly! + private static let persianDotSafeRegex: NSRegularExpression = { + let guards = [ + "(? String { + let isPTT = (HotkeyManager.shared.currentMode == .pushToTalk) + return process(text: text, isPushToTalk: isPTT) + } + + public func process(text: String, isPushToTalk: Bool) -> String { var result = text.trimmingCharacters(in: .whitespacesAndNewlines) if result.isEmpty { return "" } @@ -23,7 +68,7 @@ public final class TextProcessor { if !botCmd.body.isEmpty { var bodyText = botCmd.body if SonioxSettings.shared.voicePunctuation { - bodyText = applyVoicePunctuation(bodyText) + bodyText = applyVoicePunctuation(bodyText, allowNewlines: true) } if SonioxSettings.shared.domainVocabulary { bodyText = applyDomainVocabulary(bodyText) @@ -32,6 +77,9 @@ public final class TextProcessor { if SonioxSettings.shared.normalizeText { bodyText = normalizeText(bodyText) } + if !isPushToTalk { + bodyText = stripTrailingEndTrigger(bodyText) + } processedBody = bodyText.trimmingCharacters(in: .whitespacesAndNewlines) } else { processedBody = "" @@ -44,82 +92,107 @@ public final class TextProcessor { } } - // 1. Voice Punctuation Commands + // 1. Voice Punctuation Commands (Context-Aware) if SonioxSettings.shared.voicePunctuation { - result = applyVoicePunctuation(result) + result = applyVoicePunctuation(result, allowNewlines: true) } - + // 2. Domain Vocabulary Enhancement if SonioxSettings.shared.domainVocabulary { result = applyDomainVocabulary(result) } - + // 3. Number Formatting result = applyNumberFormatting(result, format: SonioxSettings.shared.numberFormat) - - // 3.5. Sanitize foreign hallucinations & word loops + + // 3.5. Sanitize silence noise artifacts result = SonioxLiveSession.sanitizeText(result) - + // 4. Text Normalization if SonioxSettings.shared.normalizeText { result = normalizeText(result) } - - // 5. Wake Word & End Trigger sanitization - result = stripTrailingEndTrigger(result) - - return result.trimmingCharacters(in: .whitespacesAndNewlines) + + // 5. End Trigger sanitization ONLY in Hands-Free / Toggle mode (never delete words in Push-To-Talk!) + if !isPushToTalk { + result = stripTrailingEndTrigger(result) } - /// Lightweight inline formatter applied to live streaming chunks so words, domain terms, - /// and numbers match the final post-processed text in real time. - public func processLiveChunk(_ text: String) -> String { - if text.isEmpty { return "" } - let hadLeadingSpace = text.first?.isWhitespace == true - let hadTrailingSpace = text.last?.isWhitespace == true - - var result = text + return result.trimmingCharacters(in: .whitespacesAndNewlines) + } + + /// Formats the running live candidate consistently during simultaneous word-by-word typing. + /// Keeps output single-line (no `\n`) so live Backspace tail-rewrites are 100% deterministic across all apps; + /// newlines are applied cleanly at `commitFinalText`. + public func processLivePreview(_ text: String) -> String { + let trimmedInput = text.trimmingCharacters(in: .whitespacesAndNewlines) + if trimmedInput.isEmpty { return "" } + let hadTrailingSpace = text.unicodeScalars.last.map { CharacterSet.whitespaces.contains($0) } ?? false + + if let botCmd = BotCommandProcessor.parse(text: trimmedInput) { + if botCmd.body.isEmpty { + return botCmd.command + (hadTrailingSpace ? " " : "") + } + var body = botCmd.body if SonioxSettings.shared.voicePunctuation { - result = applyVoicePunctuation(result) + body = applyVoicePunctuation(body, allowNewlines: false) } if SonioxSettings.shared.domainVocabulary { - result = applyDomainVocabulary(result) + body = applyDomainVocabulary(body) } - result = applyNumberFormatting(result, format: SonioxSettings.shared.numberFormat) - - let resultHasLeadingSpace = result.first?.isWhitespace == true - let resultHasTrailingSpace = result.last?.isWhitespace == true - let trimmed = result.trimmingCharacters(in: .whitespaces) - if trimmed.isEmpty { return text } - let keepLeading = hadLeadingSpace || resultHasLeadingSpace - let keepTrailing = hadTrailingSpace || resultHasTrailingSpace - return (keepLeading ? " " : "") + trimmed + (keepTrailing ? " " : "") + body = applyNumberFormatting(body, format: SonioxSettings.shared.numberFormat) + if SonioxSettings.shared.normalizeText { + body = normalizeSingleLine(body) + } + return "\(botCmd.command) \(body)" + (hadTrailingSpace ? " " : "") } - public func applyDomainVocabularyInline(_ text: String) -> String { + var result = trimmedInput + if SonioxSettings.shared.voicePunctuation { + result = applyVoicePunctuation(result, allowNewlines: false) + } + if SonioxSettings.shared.domainVocabulary { + result = applyDomainVocabulary(result) + } + result = applyNumberFormatting(result, format: SonioxSettings.shared.numberFormat) + result = SonioxLiveSession.sanitizeText(result) + if SonioxSettings.shared.normalizeText { + result = normalizeSingleLine(result) + } + if HotkeyManager.shared.currentMode != .pushToTalk { + result = stripTrailingEndTrigger(result) + } + let clean = result.trimmingCharacters(in: .whitespacesAndNewlines) + if clean.isEmpty { return "" } + return clean + (hadTrailingSpace ? " " : "") + } + + /// Legacy chunk helper preserved for compatibility. + public func processLiveChunk(_ text: String) -> String { + return processLivePreview(text) + } + + public func applyDomainVocabularyInline(_ text: String) -> String { return applyDomainVocabulary(text) } - private func applyVoicePunctuation(_ text: String) -> String { + private func applyVoicePunctuation(_ text: String, allowNewlines: Bool) -> String { var t = " " + text + " " + while t.contains(" ") { + t = t.replacingOccurrences(of: " ", with: " ") + } - // Persian Voice Commands + // Unambiguous multi-word & symbol commands first let persianMappings: [(String, String)] = [ (" علامت سوال", "؟"), (" علامت سؤال", "؟"), (" علامت پرسش", "؟"), (" علامت تعجب", "!"), (" نقطه ویرگول", "؛"), - (" خط بعد", "\n"), - (" سطر بعد", "\n"), - (" سر خط", "\n"), - (" اینتر", "\n"), - (" برو خط بعد", "\n"), - (" نقطه", "."), - (" ویرگول", "،"), - (" کاما", "،"), (" دو نقطه", ":"), (" سه نقطه", "..."), + (" ویرگول", "،"), + (" کاما", "،"), (" گیومه باز", " «"), (" گیومه بسته", "» "), (" پرانتز باز", " ("), @@ -130,6 +203,29 @@ public final class TextProcessor { t = t.replacingOccurrences(of: cmd, with: rep, options: .caseInsensitive) } + // Context-guarded "نقطه" (protects "نقطه ضعف", "این نقطه", etc.) + t = Self.persianDotSafeRegex.stringByReplacingMatches( + in: t, + options: [], + range: NSRange(location: 0, length: t.utf16.count), + withTemplate: "." + ) + + if allowNewlines { + t = Self.persianNewlineSafeRegex.stringByReplacingMatches( + in: t, + options: [], + range: NSRange(location: 0, length: t.utf16.count), + withTemplate: "\n" + ) + t = Self.persianEnterSafeRegex.stringByReplacingMatches( + in: t, + options: [], + range: NSRange(location: 0, length: t.utf16.count), + withTemplate: "\n" + ) + } + // English Voice Commands let englishMappings: [(String, String)] = [ (" question mark", "?"), @@ -137,12 +233,8 @@ public final class TextProcessor { (" exclamation point", "!"), (" semi colon", ";"), (" semicolon", ";"), - (" new line", "\n"), - (" enter key", "\n"), (" full stop", "."), - (" period", "."), (" comma", ","), - (" colon", ":"), (" ellipsis", "..."), (" open quote", " \""), (" close quote", "\" "), @@ -154,6 +246,18 @@ public final class TextProcessor { t = t.replacingOccurrences(of: cmd, with: rep, options: .caseInsensitive) } + if allowNewlines { + t = t.replacingOccurrences(of: " new line", with: "\n", options: .caseInsensitive) + t = t.replacingOccurrences(of: " enter key", with: "\n", options: .caseInsensitive) + } + + t = Self.englishPeriodSafeRegex.stringByReplacingMatches( + in: t, + options: [], + range: NSRange(location: 0, length: t.utf16.count), + withTemplate: "." + ) + return t } @@ -174,6 +278,8 @@ public final class TextProcessor { ("سانی اوکس", "Soniox"), ("سانیوکس", "Soniox"), ("سانی اکس", "Soniox"), + ("ثانیه ایکس", "Soniox"), + ("ثانیه یکس", "Soniox"), ("تیم بای", "TeamBy"), ("تیمبی", "TeamBy"), ("دوودی", "Dovodi"), @@ -191,6 +297,7 @@ public final class TextProcessor { ("فلاتر", "Flutter"), ("وایارگارد", "WireGuard"), ("وایرگارد", "WireGuard"), + ("پروتون وی پی ان", "ProtonVPN"), ("میکروتیک", "MikroTik"), ("هرمس", "Hermes"), ("نکست جی اس", "Next.js"), @@ -276,43 +383,54 @@ public final class TextProcessor { } } + private func normalizeSingleLine(_ text: String) -> String { + let collapsed = text.replacingOccurrences(of: "\n", with: " ").replacingOccurrences(of: "\r", with: " ") + return normalizeText(collapsed) + } + private func normalizeText(_ text: String) -> String { - var t = text - while t.contains(" ") { - t = t.replacingOccurrences(of: " ", with: " ") - } - let punctuationList = [".", "،", "؛", "؟", "!", ":", ")", "»"] - for p in punctuationList { - t = t.replacingOccurrences(of: " " + p, with: p) - } - t = t.replacingOccurrences(of: "...", with: "…") - for p in ["،", "؛", "؟", "!", "…"] { - t = t.replacingOccurrences(of: p, with: p + " ") - } - // Only add space after "." when it is NOT between two digits (preserve 4.3, 3.8, IP addresses) - let dotNotDecimal = try! NSRegularExpression(pattern: #"(\.)(?![0-9۰-۹\s\.])"#, options: []) - t = dotNotDecimal.stringByReplacingMatches(in: t, options: [], range: NSRange(location: 0, length: t.utf16.count), withTemplate: ". ") - t = t.replacingOccurrences(of: "…", with: "...") - let speechFixes: [(String, String)] = [ - (" ماا ", " ما "), - (" اینپیگیری ", " این پیگیری "), - (" می‌کنکنیم ", " می‌کنیم "), - (" سر سمانش ", " سر و سامانش "), - (" دست و پا گیرلی ", " دست و پا گیر ولی ") - ] - for (bad, good) in speechFixes { - t = t.replacingOccurrences(of: bad, with: good) - } - - t = t.replacingOccurrences(of: "( ", with: "(") - t = t.replacingOccurrences(of: "« ", with: "«") - - while t.contains(" ") { - t = t.replacingOccurrences(of: " ", with: " ") + // Normalize line-by-line so explicit `\n` line breaks are preserved! + let lines = text.components(separatedBy: "\n") + let normalizedLines = lines.map { rawLine -> String in + var t = rawLine + while t.contains(" ") { + t = t.replacingOccurrences(of: " ", with: " ") + } + let punctuationList = [".", "،", "؛", "؟", "!", ":", ")", "»"] + for p in punctuationList { + t = t.replacingOccurrences(of: " " + p, with: p) + } + t = t.replacingOccurrences(of: "...", with: "…") + for p in ["،", "؛", "؟", "!", "…"] { + t = t.replacingOccurrences(of: p, with: p + " ") + } + t = Self.dotNotDecimalRegex.stringByReplacingMatches( + in: t, + options: [], + range: NSRange(location: 0, length: t.utf16.count), + withTemplate: ". " + ) + t = t.replacingOccurrences(of: "…", with: "...") + let speechFixes: [(String, String)] = [ + (" ماا ", " ما "), + (" اینپیگیری ", " این پیگیری "), + (" می‌کنکنیم ", " می‌کنیم "), + (" سر سمانش ", " سر و سامانش "), + (" دست و پا گیرلی ", " دست و پا گیر ولی ") + ] + for (bad, good) in speechFixes { + t = t.replacingOccurrences(of: bad, with: good) + } + t = t.replacingOccurrences(of: "( ", with: "(") + t = t.replacingOccurrences(of: "« ", with: "«") + while t.contains(" ") { + t = t.replacingOccurrences(of: " ", with: " ") + } + return t.trimmingCharacters(in: .whitespaces) } - return t.trimmingCharacters(in: .whitespacesAndNewlines) + return normalizedLines.joined(separator: "\n").trimmingCharacters(in: .whitespacesAndNewlines) } - + public func stripTrailingEndTrigger(_ text: String) -> String { var t = text.trimmingCharacters(in: .whitespacesAndNewlines) let range1 = NSRange(location: 0, length: t.utf16.count)