react-native-davoice-tts 1.0.291 → 1.0.293

package/ios/TTSRNBridge/DavoiceTTS.xcframework/{ios-arm64_x86_64-simulator/DavoiceTTS.framework/DaVoiceSTT.swift.ofer → ios-arm64/DavoiceTTS.framework/DaVoiceSTT.swift.AEC.CRASH.ETC}

@@ -18,6 +18,22 @@ public final class STT: NSObject, SFSpeechRecognizerDelegate {
 
     // Global AEC toggle (default ON to keep existing behavior)
     public var aecEnabled: Bool = true
+    // If true, force VP/AEC ON for a short window after session activation while routes settle.
+    public var forceAECDuringRouteWarmup: Bool = true
+    public var aecRouteWarmupSeconds: Double = 20.0
+    // If true, always request 16k input sample rate from AVAudioSession.
+    // iOS may still override this depending on route / voice processing constraints.
+    public var force16kMicSampleRate: Bool = false
+    // If true, use old SV gate behavior (immediate open/close + full pre-roll flush).
+    public var useLegacySpeakerGateBehavior: Bool = false
+    // If true, keep gate open for a short hangover after the last positive match.
+    public var useSpeakerGateHangover: Bool = true
+    public var speakerGateHangoverSeconds: Double = 0.40
+    // If true, override SV tailSeconds to 0.5s for faster switching tests.
+    public var useShortSpeakerVerificationTailWindow: Bool = true
+    public var shortSpeakerVerificationTailSeconds: Float = 0.5
+    // In protected mode, flush only this much recent pre-roll when gate reopens.
+    public var speakerPreRollFlushMaxSeconds: Double = 0.5
 
     // MARK: - Private
     private var speechRecognizer: SFSpeechRecognizer?
@@ -25,6 +41,9 @@ public final class STT: NSObject, SFSpeechRecognizerDelegate {
     private var audioEngine: AVAudioEngine?
     private var recognitionTask: SFSpeechRecognitionTask?
     private var audioSession: AVAudioSession?
+    private let aecSessionActivationLock = NSLock()
+    private var lastAECSessionActivationAt: CFTimeInterval = 0
+    private var aecSessionIsActive: Bool = false
     private var isTearingDown: Bool = false
     private var sessionId: String?
     private var priorAudioCategory: AVAudioSession.Category?
@@ -32,8 +51,7 @@ public final class STT: NSObject, SFSpeechRecognizerDelegate {
     private var averagePowerForChannel1: Float = 0
     // Add to STT
     private var isAdjustingRoute = false
-    private var lastRouteTune: CFAbsoluteTime = 0
-    private let routeTuneCooldown: CFTimeInterval = 0.5
+    private var lastRouteSignature: String = ""
 
     private var playbackNode: AVAudioPlayerNode?
     private var seenRealSpeech = false            // flips true after first non-blank token
@@ -75,11 +93,8 @@ public final class STT: NSObject, SFSpeechRecognizerDelegate {
 
     private(set) var sttActive = false
     // STT.swift  (add near `private var playbackNode: AVAudioPlayerNode?`)
-    private var ttsEQ: AVAudioUnitEQ?
+//    private var ttsEQ: AVAudioUnitEQ?
 
-    // partial cadence monitor
-    private var emaPartialGap: Double = 0   // exponential moving average of time between partials
-    private let emaAlpha: Double = 0.3
     // Add near your other state:
     private var ioLatchActiveGen: UInt64 = 0
 
@@ -105,11 +120,45 @@ public final class STT: NSObject, SFSpeechRecognizerDelegate {
     private var activeTaskGen: UInt64 = 0
     private var micPaused: Bool = false
 
+    // --- Optional speaker verification gate ---
+    private struct SpeakerVerificationStartConfig {
+        let enrollment: SpeakerEnrollment
+        let config: SpeakerVerificationConfig
+    }
+    private let speakerVerificationQueue = DispatchQueue(label: "stt.sv.queue")
+    private let speakerVerificationStateLock = NSLock()
+    private var speakerVerificationStartConfig: SpeakerVerificationStartConfig?
+    private var speakerVerificationEngine: SpeakerVerificationEngine?
+    private var speakerVerificationFrameSize: Int = 0
+    private var speakerVerificationInputBuffer: [Float] = []
+    private var speakerGateOpen: Bool = true
+    private var speakerGateEnabled: Bool = false
+    private var speakerVerificationErrorSent: Bool = false
+    private var speakerPreRollBuffers: [AVAudioPCMBuffer] = []
+    private var speakerPreRollFrames: Int = 0
+    private var speakerPreRollMaxFrames: Int = 0
+    private var speakerPendingPreRollFlush: Bool = false
+    private let speakerPreRollSeconds: Double = 1.0
+    private var speakerVerificationThreshold: Float = 0
+    private var speakerVerificationFrameSeq: UInt64 = 0
+    private var speakerVerificationSourceSampleRate: Int = 0
+    private var speakerVerificationTargetSampleRate: Int = 0
+    private var speakerVerificationResampleCarry: [Float] = []
+    private var speakerVerificationResamplePos: Double = 0
+    private var speakerLastPositiveMatchAt: CFTimeInterval = 0
+
     // --- Speech recognition lite pause (counter-based) ---
     private let speechPauseLock = NSLock()
     private var speechRecognitionPauseCount: Int = 0
     private var speechRecognitionPaused: Bool = false
     @inline(__always)
+    private func isSpeechRecognitionLitePaused() -> Bool {
+        speechPauseLock.lock()
+        let paused = speechRecognitionPaused
+        speechPauseLock.unlock()
+        return paused
+    }
+    @inline(__always)
     private func resetSpeechRecognitionLitePauseState(_ why: String) {
         speechPauseLock.lock()
         speechRecognitionPauseCount = 0
@@ -394,10 +443,6 @@ private func pollOnMain(timeoutSec: TimeInterval,
         }
         micPaused = true
 
-        // ✅ CRITICAL: invalidate any pending async tap installs/probes/latches.
-        // This prevents closures scheduled earlier from touching nodes after engine is torn down.
-        bumpGraphGen()
-
         let session = AVAudioSession.sharedInstance()
 
         // Save current session config (so we can restore on unpause)
@@ -459,6 +504,7 @@ private func pollOnMain(timeoutSec: TimeInterval,
             // Use this if we ever have duck others
             // try session.setActive(false, options: [.notifyOthersOnDeactivation])
             try session.setActive(false, options: [])
+            markAECSessionActivation(false, reason: "pauseMicrophone-pre")
             NSLog("[STT] pauseMicrophone(): setActive false")
         } catch {
             NSLog("[STT] pauseMicrophone(): failed to switch setActive false: \(error.localizedDescription)")
@@ -473,6 +519,7 @@ private func pollOnMain(timeoutSec: TimeInterval,
         // Switch to playback-only session so iOS releases the mic (indicator off)
         do {
             try session.setActive(true, options: [])
+            markAECSessionActivation(true, reason: "pauseMicrophone-playback")
             NSLog("[STT] pauseMicrophone(): session set to .playback (mic released)")
         } catch {
             NSLog("[STT] pauseMicrophone(): failed to switch to session.setActive with .playback: \(error.localizedDescription)")
@@ -494,6 +541,7 @@ private func pollOnMain(timeoutSec: TimeInterval,
             // Restore previous session category/mode/options and IO prefs
             do {
                 try session.setActive(false, options: [.notifyOthersOnDeactivation])
+                markAECSessionActivation(false, reason: "unPauseMicrophone-pre")
             } catch {
                 NSLog("[STT] unPauseMicrophone: setActive(false) failed: \(error.localizedDescription)")
             }
@@ -521,6 +569,7 @@ private func pollOnMain(timeoutSec: TimeInterval,
 
             do {
                 try session.setActive(true, options: [])
+                markAECSessionActivation(true, reason: "unPauseMicrophone")
             } catch {
                 NSLog("[STT] unPauseMicrophone: setActive(true) failed: \(error.localizedDescription)")
             }
@@ -613,32 +662,11 @@ private func pollOnMain(timeoutSec: TimeInterval,
         return true
     }
 
+ 
     @inline(__always)
     private func safeRemoveTap(_ node: AVAudioNode?, bus: AVAudioNodeBus = 0) {
-        guard let n = node else { return }
-        // MUST be called on main to avoid races with teardown/rebuild
-        if !Thread.isMainThread {
-            DispatchQueue.main.async { [weak self] in self?.safeRemoveTap(n, bus: bus) }
-            return
-        }
-        guard n.engine != nil else { return }
-        n.removeTap(onBus: bus)
-    }
-
-    @inline(__always)
-    private func safeInstallTap(_ node: AVAudioNode?,
-                                bus: AVAudioNodeBus = 0,
-                                bufferSize: AVAudioFrameCount = 128,
-                                format: AVAudioFormat? = nil,
-                                block: @escaping AVAudioNodeTapBlock) {
-        guard let n = node else { return }
-        // MUST be called on main to avoid races with teardown/rebuild
-        if !Thread.isMainThread {
-            DispatchQueue.main.async { [weak self] in self?.safeInstallTap(n, bus: bus, bufferSize: bufferSize, format: format, block: block) }
-            return
-        }
-        guard n.engine != nil else { return }
-        n.installTap(onBus: bus, bufferSize: bufferSize, format: format, block: block)
+        guard let n = node, n.engine != nil else { return }   // only remove if still attached
+        try? n.removeTap(onBus: bus)
     }
 
     // MARK: - Public API (native replacements for the former RCT methods)
@@ -668,7 +696,7 @@ private func pollOnMain(timeoutSec: TimeInterval,
             // >>> IMPORTANT: ensure no previous tap is left behind
             self.safeRemoveTap(out, bus: 0)
 
-            self.safeInstallTap(out, bus: 0, bufferSize: 128, format: nil) { [weak self, weak out] _, _ in
+            out.installTap(onBus: 0, bufferSize: 128, format: nil) { [weak self, weak out] _, _ in
                 guard let self = self, gen == self.graphGen else { return }
                 if fired { return }
                 fired = true
@@ -758,6 +786,10 @@ private func pollOnMain(timeoutSec: TimeInterval,
             NSLog("[STT] rearmTask(\(reason)) suppressed (micPaused)")
             return
         }
+        if isSpeechRecognitionLitePaused() {
+            NSLog("[STT] rearmTask(\(reason)) suppressed (speechRecognitionPaused)")
+            return
+        }
 
         // -----------------
         recognitionTask?.cancel()
@@ -774,6 +806,10 @@ private func checkTaskHealth() {
         NSLog("[STT] watchdog: isTearingDown || isTelephonyInterrupted || isRecoveringAfterTelephony -- DOING NOTHING")
         return 
     }
+    if isSpeechRecognitionLitePaused() {
+        NSLog("[STT] watchdog: speechRecognitionPaused -- DOING NOTHING")
+        return
+    }
     if micPaused {
         NSLog("[STT] watchdog: micPaused -- DOING NOTHING")
         return
@@ -848,8 +884,26 @@ private func checkTaskHealth() {
 }
 
     public func startSpeech(localeStr: String?) {
-        NSLog("[STT] startSpeech(locale=\(localeStr ?? "nil"))")
-        lastLocaleStr = localeStr!
+        startSpeechInternal(localeStr: localeStr, speakerVerificationConfig: nil)
+    }
+
+    public func startSpeech(localeStr: String?, onboardingJsonPath: String) {
+        do {
+            let loaded = try loadSpeakerVerificationStartConfig(onboardingJsonPath: onboardingJsonPath)
+            startSpeechInternal(localeStr: localeStr, speakerVerificationConfig: loaded)
+        } catch {
+            sendResult(error: ["message": "Failed to load onboarding JSON: \(error.localizedDescription)"],
+                       bestTranscription: nil,
+                       transcriptions: nil,
+                       isFinal: nil)
+        }
+    }
+
+    private func startSpeechInternal(localeStr: String?,
+                                     speakerVerificationConfig: SpeakerVerificationStartConfig?) {
+        NSLog("[STT] startSpeech(locale=\(localeStr ?? "nil"), sv=\(speakerVerificationConfig == nil ? "off" : "on"))")
+        lastLocaleStr = localeStr ?? ""
+        speakerVerificationStartConfig = speakerVerificationConfig
         if recognitionTask != nil {
             sendResult(error: ["code": "already_started", "message": "Speech recognition already started!"],
                        bestTranscription: nil, transcriptions: nil, isFinal: nil)
@@ -960,8 +1014,13 @@ private func checkTaskHealth() {
                 catch { NSLog("[STT] setCategory failed: \(error.localizedDescription)") }
             }
 
-            do { try s.setActive(true, options: []) }
-            catch { NSLog("[STT] setActive failed: \(error.localizedDescription)") }
+            do {
+                try s.setActive(true, options: [])
+                self.markAECSessionActivation(true, reason: "updateSessionRouting")
+            } catch {
+                NSLog("[STT] setActive failed: \(error.localizedDescription)")
+                self.markAECSessionActivation(false, reason: "updateSessionRouting-failed")
+            }
 
             // Optional: force 16k after activation
             self.force16kIfPossible(s)
@@ -978,6 +1037,10 @@ private func checkTaskHealth() {
 
     // ↓↓↓ preferred settings helper
     private func force16kIfPossible(_ session: AVAudioSession) {
+        if force16kMicSampleRate {
+            try? session.setPreferredSampleRate(16_000)
+        }
+
         let hasExternalOutput = session.currentRoute.outputs.contains {
             switch $0.portType {
             case .headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .airPlay, .carAudio, .usbAudio:
@@ -1004,6 +1067,27 @@ private func checkTaskHealth() {
         try? session.setPreferredIOBufferDuration(0.02)
     }
 
+    private func markAECSessionActivation(_ active: Bool, reason: String) {
+        let now = CACurrentMediaTime()
+        aecSessionActivationLock.lock()
+        aecSessionIsActive = active
+        if active { lastAECSessionActivationAt = now }
+        else { lastAECSessionActivationAt = 0 }
+        aecSessionActivationLock.unlock()
+        NSLog("[STT] AEC session activation(\(reason)): active=\(active ? "YES" : "NO") t=\(String(format: "%.3f", now))")
+    }
+
+    private func isInAECRouteWarmupWindow() -> Bool {
+        guard aecEnabled, forceAECDuringRouteWarmup, aecRouteWarmupSeconds > 0 else { return false }
+        let now = CACurrentMediaTime()
+        aecSessionActivationLock.lock()
+        let isActive = aecSessionIsActive
+        let lastActiveAt = lastAECSessionActivationAt
+        aecSessionActivationLock.unlock()
+        guard isActive, lastActiveAt > 0 else { return false }
+        return (now - lastActiveAt) < aecRouteWarmupSeconds
+    }
+
     // MARK: - Core logic (kept intact, including AEC order/steps)
 
     /// Returns true if no errors occurred (identical flow & calls as ObjC).
@@ -1016,6 +1100,7 @@ private func checkTaskHealth() {
 
         do { try session.setActive(false, options: [.notifyOthersOnDeactivation]) }
         catch { NSLog("[STT] setActive false failed: \(error.localizedDescription)") }
+        markAECSessionActivation(false, reason: "setupAudioSession-pre")
 
         // Build options to match our routing rules
         // (defaultToSpeaker only when no external output is active)
@@ -1040,10 +1125,17 @@ private func checkTaskHealth() {
 
         do { try session.setActive(false, options: [.notifyOthersOnDeactivation]) }
         catch { NSLog("[STT] setActive false failed: \(error.localizedDescription)") }
+        markAECSessionActivation(false, reason: "setupAudioSession-reconfigure")
 
         // Force 16k before and after activation (some routes settle only after setActive)
         force16kIfPossible(session)
-        do { try session.setActive(true) } catch { err = error as NSError }
+        do {
+            try session.setActive(true)
+            markAECSessionActivation(true, reason: "setupAudioSession")
+        } catch {
+            err = error as NSError
+            markAECSessionActivation(false, reason: "setupAudioSession-failed")
+        }
         NSLog("[STT] session SR=%.1f inCh=%d outCh=%d (wanted 16000)",
               session.sampleRate,
               Int(session.inputNumberOfChannels),
@@ -1061,6 +1153,65 @@ private func checkTaskHealth() {
         return true
     }
 
+    private func shouldUseVoiceProcessingForCurrentRoute() -> Bool {
+        guard aecEnabled else { return false }
+        if isInAECRouteWarmupWindow() { return true }
+        let s = AVAudioSession.sharedInstance()
+        let speakerRoute = s.currentRoute.outputs.contains { $0.portType == .builtInSpeaker }
+        let usingBuiltInMic = (s.preferredInput?.portType == .builtInMic) ||
+                              (s.currentRoute.inputs.first?.portType == .builtInMic)
+        return speakerRoute && usingBuiltInMic
+    }
+
+    private func configureVoiceProcessingDucking(_ inputNode: AVAudioInputNode) {
+        if #available(iOS 17.0, *) {
+            var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
+            duck.enableAdvancedDucking = false
+            duck.duckingLevel = .min
+            inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
+        }
+    }
+
+    private func reconcileAEC(on engine: AVAudioEngine?, reason: String, allowRebuild: Bool = true) {
+        guard let engine = engine else { return }
+        let inputNode = engine.inputNode
+        let desiredVP = shouldUseVoiceProcessingForCurrentRoute()
+
+        if #available(iOS 13.0, *) {
+            let currentVP = inputNode.isVoiceProcessingEnabled
+            if currentVP == desiredVP {
+                if desiredVP { configureVoiceProcessingDucking(inputNode) }
+                NSLog("[STT] AEC reconcile(\(reason)): unchanged vp=\(currentVP ? "ON" : "OFF")")
+                return
+            }
+        }
+
+        do {
+            try inputNode.setVoiceProcessingEnabled(desiredVP)
+            if desiredVP { configureVoiceProcessingDucking(inputNode) }
+            NSLog("[STT] AEC reconcile(\(reason)): set vp=\(desiredVP ? "ON" : "OFF")")
+        } catch {
+            NSLog("[STT] AEC reconcile(\(reason)) failed: \(error.localizedDescription)")
+            if allowRebuild && sttActive && !isTearingDown && !micPaused &&
+                !isTelephonyInterrupted && !isRecoveringAfterTelephony {
+                rebuildEngineGraphAndRestart(reason: "aec-reconcile-\(reason)")
+            }
+        }
+    }
+
+    private func scheduleAECReconcileRetries(reason: String,
+                                             attempts: Int = 3,
+                                             stepSec: TimeInterval = 0.20) {
+        guard attempts > 0 else { return }
+        for i in 1...attempts {
+            DispatchQueue.main.asyncAfter(deadline: .now() + stepSec * Double(i)) { [weak self] in
+                guard let self = self else { return }
+                if self.isTearingDown || self.micPaused || self.isTelephonyInterrupted { return }
+                self.reconcileAEC(on: self.audioEngine, reason: "\(reason)-retry\(i)", allowRebuild: false)
+            }
+        }
+    }
+
     private func currentInputFormat(_ engine: AVAudioEngine) -> AVAudioFormat? {
         // Prefer whatever CoreAudio currently provides; avoid cached formats.
         let fmt = engine.inputNode.outputFormat(forBus: 0)
@@ -1097,22 +1248,8 @@ private func recoverAfterTelephonyInterruption() {
     _ = setupAudioSession()                          // ✅ ensures correct mode/options
     forceSpeakerIfReceiver("recoverAfterTelephony")  // ✅ receiver -> speaker now
 
-    let s = AVAudioSession.sharedInstance()
-    let speakerRoute = s.currentRoute.outputs.contains { $0.portType == .builtInSpeaker }
-    let usingBuiltInMic = (s.preferredInput?.portType == .builtInMic) ||
-                          (s.currentRoute.inputs.first?.portType == .builtInMic)
-    let willUseVP = speakerRoute && usingBuiltInMic
-
     let inputNode = eng.inputNode
-    if aecEnabled && willUseVP {
-        try? inputNode.setVoiceProcessingEnabled(true)
-        if #available(iOS 17.0, *) {
-            var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
-            duck.enableAdvancedDucking = false
-            duck.duckingLevel = .min
-            inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
-        }
-    }
+    reconcileAEC(on: eng, reason: "recover-after-telephony-prestart", allowRebuild: false)
 
     eng.reset()
     let micMixer = AVAudioMixerNode()
@@ -1131,6 +1268,8 @@ private func recoverAfterTelephonyInterruption() {
         try eng.start()
         armFirstIOCycleLatch(on: eng)
         tryClearCaptureLossAfterStartSucceeded()
+        reconcileAEC(on: eng, reason: "recover-after-telephony-poststart", allowRebuild: false)
+        scheduleAECReconcileRetries(reason: "recover-after-telephony")
     } catch {
         NSLog("[STT] recover: engine.start failed → will let watchdog retry: \(error)")
         return
@@ -1176,7 +1315,11 @@ private func recoverAfterTelephonyInterruption() {
             return []
         }
         do {
-            let contents = try String(contentsOfFile: filePath, encoding: .utf8)
+            var contents = try String(contentsOfFile: filePath, encoding: .utf8)
+            // ✅ MIN FIX: remove UTF-8 BOM if present (often only affects the first token)
+            if contents.unicodeScalars.first == "\u{FEFF}" {
+                contents.unicodeScalars.removeFirst()
+            }
             let rawItems = contents.components(separatedBy: ",")
             var cleaned: [String] = []
             cleaned.reserveCapacity(rawItems.count)
@@ -1210,13 +1353,20 @@ private func recoverAfterTelephonyInterruption() {
         if #available(iOS 16, *) { req.addsPunctuation = true }
         req.shouldReportPartialResults = true
         //if #available(iOS 13.0, *) { req.taskHint = .dictation }
-        req.contextualStrings = loadContextualStrings()
+        let cs: [String] = loadContextualStrings()
+        req.contextualStrings = cs
+        NSLog("[STT] makeFreshRequest contextualStrings count=\(cs.count) sample=\(cs.prefix(10)) file=\(Bundle.main.path(forResource: "words_flattened", ofType: "txt") ?? "nil")")
+
         self.recognitionRequest = req
-        NSLog("makeFreshRequest()")
+        NSLog("[STT] makeFreshRequest()")
         return req
     }
 
     private func startTask(_ req: SFSpeechAudioBufferRecognitionRequest) {
+        if isSpeechRecognitionLitePaused() {
+            NSLog("[STT] startTask suppressed (speechRecognitionPaused)")
+            return
+        }
         NSLog("starting recognitionTask")
         lastTaskStartAt = CACurrentMediaTime()
         lastResultAt = lastTaskStartAt
@@ -1240,14 +1390,17 @@ private func recoverAfterTelephonyInterruption() {
 
             func markIfReal(_ r: SFSpeechRecognitionResult?) {
                 guard let r = r else { return }
-                let best = r.bestTranscription.formattedString.trimmingCharacters(in: .whitespacesAndNewlines)
-                if !best.isEmpty ||
-                r.transcriptions.contains(where: { !$0.formattedString.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) {
-                    if !self.seenRealSpeech {
-                        self.seenRealSpeech = true
-                        NSLog("first real speech detected -> onSpeechStart to JS")
-                        self.sendEvent(name: "onSpeechStart", body: nil)
-                    }
+
+                // ✅ Do NOT use formattedString here (it normalizes spacing/punctuation/number formatting).
+                // Instead, treat "real speech" as "we have at least one non-empty segment substring".
+                let hasReal = r.bestTranscription.segments.contains {
+                    !$0.substring.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+                }
+
+                if hasReal && !self.seenRealSpeech {
+                    self.seenRealSpeech = true
+                    NSLog("first real speech detected -> onSpeechStart to JS")
+                    self.sendEvent(name: "onSpeechStart", body: nil)
                 }
             }
             markIfReal(result)
@@ -1276,9 +1429,9 @@ private func recoverAfterTelephonyInterruption() {
             }
 
             let isFinal = result.isFinal
-            let parts = result.transcriptions.map { $0.formattedString }
+            let parts = result.transcriptions.map { $0.segments.map { $0.substring }.joined(separator: " ") }
             self.sendResult(error: nil,
-                            bestTranscription: result.bestTranscription.formattedString,
+                            bestTranscription: result.bestTranscription.segments.map { $0.substring }.joined(separator: " "),
                             transcriptions: parts,
                             isFinal: isFinal)
 
@@ -1338,6 +1491,24 @@ private func recoverAfterTelephonyInterruption() {
         }
         mixerProbeActive = false
         mixerProbeCompletions.removeAll()
+        speakerVerificationEngine = nil
+        speakerVerificationFrameSize = 0
+        speakerVerificationInputBuffer.removeAll(keepingCapacity: false)
+        speakerVerificationThreshold = 0
+        speakerVerificationFrameSeq = 0
+        speakerVerificationSourceSampleRate = 0
+        speakerVerificationTargetSampleRate = 0
+        speakerVerificationResampleCarry.removeAll(keepingCapacity: false)
+        speakerVerificationResamplePos = 0
+        speakerLastPositiveMatchAt = 0
+        setSpeakerGateState(enabled: false, open: true)
+        speakerVerificationErrorSent = false
+        speakerPreRollBuffers.removeAll(keepingCapacity: false)
+        speakerPreRollFrames = 0
+        speakerPreRollMaxFrames = 0
+        speakerPendingPreRollFlush = false
+        lastRouteSignature = ""
+        markAECSessionActivation(false, reason: "teardown")
 
         resetAudioSession()
         savedSessionBeforePause = nil
@@ -1358,6 +1529,10 @@ private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
         NSLog("[STT] ensureEngineRunning suppressed (telephony/recovering)")
         return
     }
+    if isSpeechRecognitionLitePaused() {
+        NSLog("[STT] ensureEngineRunning(\(reason)) suppressed (speechRecognitionPaused)")
+        return
+    }
     if micPaused {
         NSLog("[STT] ensureEngineRunning(\(reason)) suppressed (micPaused)")
         return
@@ -1402,7 +1577,9 @@ private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
 
     // ensure a task is running
     if recognitionTask == nil {
-        if let req = recognitionRequest {
+        if isSpeechRecognitionLitePaused() {
+            NSLog("[STT] ensureEngineRunning(\(reason)): skip startTask (speechRecognitionPaused)")
+        } else if let req = recognitionRequest {
             startTask(req)
         } else {
             startTask(makeFreshRequest())
@@ -1482,6 +1659,10 @@ private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
         bumpGraphGen()
         NSLog("[STT] 🔄 rebuildEngineGraphAndRestart (\(reason))")
         if isTelephonyInterrupted { NSLog("[STT] rebuild suppressed during telephony"); return }
+        if isSpeechRecognitionLitePaused() {
+            NSLog("[STT] rebuild suppressed (speechRecognitionPaused)")
+            return
+        }
 
         guard hasValidCaptureNow() else {
             markCaptureLost()
@@ -1511,27 +1692,8 @@ private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
         _ = setupAudioSession()                         // ✅ keep session policy consistent
         forceSpeakerIfReceiver("rebuild:\(reason)")     // ✅ receiver -> speaker now
 
-        let s = AVAudioSession.sharedInstance()
-        let speakerRoute = s.currentRoute.outputs.contains { $0.portType == .builtInSpeaker }
-        let usingBuiltInMic = (s.preferredInput?.portType == .builtInMic) ||
-                            (s.currentRoute.inputs.first?.portType == .builtInMic)
-
         let inputNode = newEngine.inputNode
-
-        if aecEnabled, speakerRoute && usingBuiltInMic {
-            // AEC makes sense here
-            do { try inputNode.setVoiceProcessingEnabled(true) } catch {
-                NSLog("Voice processing not available: \(error)")
-            }
-            if #available(iOS 17.0, *) {
-                var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
-                duck.enableAdvancedDucking = false
-                duck.duckingLevel = .min
-                inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
-            }
-        } else {
-            // Headsets / car / AirPlay → skip AEC
-        }
+        reconcileAEC(on: newEngine, reason: "rebuild-\(reason)-prestart", allowRebuild: false)
 
         var inFmt = inputNode.outputFormat(forBus: 0)
 
@@ -1543,11 +1705,20 @@ private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
         micMixer.outputVolume = 0.0
 
 // TTS player → (de-esser) → mainMixer
-if playbackNode == nil { playbackNode = AVAudioPlayerNode() }
+if let existing = playbackNode, existing.engine !== newEngine {
+    // Node is owned by a different engine instance; recreate for this graph.
+    existing.stop()
+    playbackNode = nil
+}
+if playbackNode == nil {
+    playbackNode = AVAudioPlayerNode()
+}
 if let player = playbackNode {
-    if player.engine == nil { newEngine.attach(player) }
-            newEngine.connect(player, to: newEngine.mainMixerNode, format: nil)
-        }
+    if player.engine == nil {
+        newEngine.attach(player)
+    }
+    newEngine.connect(player, to: newEngine.mainMixerNode, format: nil)
+}
 
 // // --- Aggressive low-pass only ---
 // let deEss = AVAudioUnitEQ(numberOfBands: 1)
@@ -1572,6 +1743,8 @@ if let player = playbackNode {
             try newEngine.start()
             armFirstIOCycleLatch(on: newEngine)
             tryClearCaptureLossAfterStartSucceeded()
+            reconcileAEC(on: newEngine, reason: "rebuild-\(reason)-poststart", allowRebuild: false)
+            scheduleAECReconcileRetries(reason: "rebuild-\(reason)")
             NSLog("[STT] rebuild: engine.start() ok, running=\(newEngine.isRunning)")
         } catch {
             markCaptureLost()
@@ -1647,7 +1820,11 @@ if let player = playbackNode {
             }
         }
         if self.recognitionTask == nil {
-            startTask(self.recognitionRequest!)
+            if isSpeechRecognitionLitePaused() {
+                NSLog("[STT] rebuild: skip startTask (speechRecognitionPaused)")
+            } else {
+                startTask(self.recognitionRequest!)
+            }
         }
         if self.sttActive && !self.micPaused {
             self.installPlaybackHooks()
@@ -1656,6 +1833,10 @@ if let player = playbackNode {
 
     @objc private func handleEngineConfigChange(_ note: Notification) {
      if isTearingDown { return }      // ← add
+    if isSpeechRecognitionLitePaused() {
+        NSLog("[STT] ⚙️ AVAudioEngineConfigurationChange (ignored: speechRecognitionPaused)")
+        return
+    }
     if micPaused {
         NSLog("[STT] ⚙️ AVAudioEngineConfigurationChange (ignored: micPaused)")
         return
@@ -1667,12 +1848,18 @@ if let player = playbackNode {
             playbackNode = nil
         }
         ensureEngineRunning(reason: "engine-config-change")
+        reconcileAEC(on: audioEngine, reason: "engine-config-change")
+        scheduleAECReconcileRetries(reason: "engine-config-change")
     }
 
     @objc private func handleMediaServicesReset(_ note: Notification) {
      if isTearingDown { return }      // ← add
 
-         if micPaused {
+     if isSpeechRecognitionLitePaused() {
+        NSLog("[STT] 📺 Media services RESET (ignored: speechRecognitionPaused)")
+        return
+    }
+     if micPaused {
         NSLog("[STT] 📺 Media services RESET (ignored: micPaused)")
         return
     }
@@ -1681,6 +1868,8 @@ if let player = playbackNode {
         bumpGraphGen()
         _ = setupAudioSession()
         ensureEngineRunning(reason: "media-services-reset")
+        reconcileAEC(on: audioEngine, reason: "media-services-reset")
+        scheduleAECReconcileRetries(reason: "media-services-reset")
     }
 
 /*?????????? Why so many changes???
@@ -1720,19 +1909,52 @@ if let player = playbackNode {
 */
 @objc private func handleRouteChange(_ note: Notification) {
     if isTearingDown { return }
-        if micPaused {
+    if !sttActive {
+        NSLog("[STT] 🔀 route change (ignored: sttInactive) \(note.userInfo ?? [:])")
+        return
+    }
+    if isSpeechRecognitionLitePaused() {
+        NSLog("[STT] 🔀 route change (ignored: speechRecognitionPaused) \(note.userInfo ?? [:])")
+        return
+    }
+    if micPaused {
         NSLog("[STT] 🔀 route change (ignored: micPaused) \(note.userInfo ?? [:])")
         return
     }
 
-    NSLog("[STT] 🔀 route change: \(note.userInfo ?? [:])")
+    let info = note.userInfo ?? [:]
+    NSLog("[STT] 🔀 route change: \(info)")
     if isTelephonyInterrupted || isRecoveringAfterTelephony {
-        NSLog("[STT] 🔀 route change (ignored during telephony/recovering): \(note.userInfo ?? [:])")
+        NSLog("[STT] 🔀 route change (ignored during telephony/recovering): \(info)")
         return
     }
 
-    updateSessionRouting(selectBestInput: true)
+    let session = AVAudioSession.sharedInstance()
+    let outSig = session.currentRoute.outputs.map { $0.portType.rawValue }.joined(separator: ",")
+    let inSig = session.currentRoute.inputs.map { $0.portType.rawValue }.joined(separator: ",")
+    let routeSig = "outs=\(outSig)|ins=\(inSig)"
+    if routeSig == lastRouteSignature {
+        NSLog("[STT] 🔀 route change ignored (same route signature)")
+        return
+    }
+    lastRouteSignature = routeSig
+
+    if let reasonVal = info[AVAudioSessionRouteChangeReasonKey] as? UInt,
+       let reason = AVAudioSession.RouteChangeReason(rawValue: reasonVal) {
+        switch reason {
+        // Match AVAudioWrapper behavior: handle concrete hardware events + route config changes.
+        case .newDeviceAvailable, .oldDeviceUnavailable, .routeConfigurationChange:
+            updateSessionRouting(selectBestInput: true)
+        default:
+            NSLog("[STT] 🔀 route change reason=\(reason.rawValue) -> skip updateSessionRouting")
+        }
+    } else {
+        NSLog("[STT] 🔀 route change reason missing -> skip updateSessionRouting")
+    }
+
     forceSpeakerIfReceiver("routeChange")
+    reconcileAEC(on: audioEngine, reason: "route-change", allowRebuild: false)
+    scheduleAECReconcileRetries(reason: "route-change")
 
     ensureEngineRunning(reason: "route-change", skipCooldown: true)
 }
@@ -1757,7 +1979,7 @@ if let player = playbackNode {
                 var fired = false
                 self.safeRemoveTap(mixer, bus: 0)
 
-                self.safeInstallTap(mixer, bus: 0, bufferSize: 128, format: nil) { [weak self, weak mixer] _, _ in
+                mixer.installTap(onBus: 0, bufferSize: 128, format: nil) { [weak self, weak mixer] _, _ in
                     guard let self = self, gen == self.graphGen else { return }
                     if fired { return }
                     fired = true
@@ -1772,7 +1994,6 @@ if let player = playbackNode {
                     }
                 }
 
-
                 DispatchQueue.main.asyncAfter(deadline: .now() + timeout) { [weak self, weak mixer] in
                     guard let self = self, gen == self.graphGen else { return }
                     if fired { return }
@@ -1857,7 +2078,12 @@ if let player = playbackNode {
             tapFramesTotal = 0
 
             // Re-activate the session (safe if already active)
-            try? AVAudioSession.sharedInstance().setActive(true, options: [])
+            do {
+                try AVAudioSession.sharedInstance().setActive(true, options: [])
+                markAECSessionActivation(true, reason: "interruption-ended")
+            } catch {
+                markAECSessionActivation(false, reason: "interruption-ended-failed")
+            }
 
             // Give routes/formats a moment to settle *before* we rebuild
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
@@ -2006,12 +2232,27 @@ if let player = playbackNode {
         lastNoInputRecoveryAt = 0
         lastRearmAt = 0
         lastReclaimAttempt = 0
-        emaPartialGap = 0
         tapFramesTotal = 0
         lastTapFramesSeen = 0
         pausedForCaptureLoss = false
         mixerProbeActive = false
         mixerProbeCompletions.removeAll()
+        speakerVerificationEngine = nil
+        speakerVerificationFrameSize = 0
+        speakerVerificationInputBuffer.removeAll(keepingCapacity: false)
+        speakerVerificationThreshold = 0
+        speakerVerificationFrameSeq = 0
+        speakerVerificationSourceSampleRate = 0
+        speakerVerificationTargetSampleRate = 0
+        speakerVerificationResampleCarry.removeAll(keepingCapacity: false)
+        speakerVerificationResamplePos = 0
+        speakerLastPositiveMatchAt = 0
+        setSpeakerGateState(enabled: false, open: true)
+        speakerVerificationErrorSent = false
+        speakerPreRollBuffers.removeAll(keepingCapacity: false)
+        speakerPreRollFrames = 0
+        speakerPreRollMaxFrames = 0
+        speakerPendingPreRollFlush = false
 
         audioSession = AVAudioSession.sharedInstance()
         guard let session = audioSession else { return }
@@ -2060,7 +2301,9 @@ if let player = playbackNode {
         }
         request.shouldReportPartialResults = true
         //if #available(iOS 13.0, *) { request.taskHint = .dictation }
-        request.contextualStrings = loadContextualStrings()
+        let cs: [String] = loadContextualStrings()
+        request.contextualStrings = cs
+        NSLog("[STT] makeFreshRequest contextualStrings count=\(cs.count) sample=\(cs.prefix(10)) file=\(Bundle.main.path(forResource: "words_flattened", ofType: "txt") ?? "nil")")
 
         guard recognitionRequest != nil else {
             sendResult(error: ["code": "recognition_init"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
@@ -2079,25 +2322,7 @@ if let player = playbackNode {
             let inputNode = engine.inputNode
             let _ = inputNode // presence check
 
-            let s = AVAudioSession.sharedInstance()
-            let speakerRoute = s.currentRoute.outputs.contains { $0.portType == .builtInSpeaker }
-            let usingBuiltInMic = (s.preferredInput?.portType == .builtInMic) ||
-                                (s.currentRoute.inputs.first?.portType == .builtInMic)
-
-            if aecEnabled, speakerRoute && usingBuiltInMic {
-                // AEC makes sense here
-                do { try inputNode.setVoiceProcessingEnabled(true) } catch {
-                    NSLog("Voice processing not available: \(error)")
-                }
-                if #available(iOS 17.0, *) {
-                    var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
-                    duck.enableAdvancedDucking = false   // disable advanced (VAD-based) ducking
-                    duck.duckingLevel = .min             // “as loud as possible” for other audio
-                    inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
-                }
-            } else {
-                // Headsets / car / AirPlay → skip AEC
-            }
+            reconcileAEC(on: engine, reason: "setup-start-prestart", allowRebuild: false)
 
             // if output node voice processing is ever needed, keep commented as in original:
             // do { try engine.outputNode.setVoiceProcessingEnabled(true) } catch { ... }
@@ -2151,7 +2376,72 @@ if let player = playbackNode {
                 return
             }
 
-            inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { [weak self] buffer, _ in
+            var tapBufferSize: AVAudioFrameCount = 1024
+            if let svStart = speakerVerificationStartConfig {
+                do {
+                    var svConfig = svStart.config
+                    let routeSampleRate = Int(round(format.sampleRate))
+                    if useShortSpeakerVerificationTailWindow {
+                        let forcedTail = max(0.1, shortSpeakerVerificationTailSeconds)
+                        svConfig.tailSeconds = forcedTail
+                        if svConfig.maxTailSeconds < forcedTail {
+                            svConfig.maxTailSeconds = forcedTail
+                        }
+                        NSLog("[STT] SV tail override enabled tailSeconds=\(forcedTail)")
+                    }
+
+                    speakerVerificationFrameSize = svConfig.frameSize
+                    speakerVerificationThreshold = svConfig.decisionThreshold
+                    speakerVerificationFrameSeq = 0
+                    speakerVerificationSourceSampleRate = routeSampleRate
+                    speakerVerificationTargetSampleRate = svConfig.sampleRate
+                    speakerVerificationResampleCarry.removeAll(keepingCapacity: true)
+                    speakerVerificationResamplePos = 0
+                    speakerLastPositiveMatchAt = 0
+                    speakerVerificationInputBuffer.removeAll(keepingCapacity: true)
+                    setSpeakerGateState(enabled: false, open: false)
+                    speakerVerificationErrorSent = false
+                    speakerPreRollBuffers.removeAll(keepingCapacity: true)
+                    speakerPreRollFrames = 0
+                    speakerPendingPreRollFlush = false
+                    speakerPreRollMaxFrames = max(1, Int(round(format.sampleRate * speakerPreRollSeconds)))
+
+                    svConfig.logLevel = .off
+                    let svEngine = try SpeakerVerificationEngine(config: svConfig)
+                    svEngine.setEnrollment(svStart.enrollment)
+                    svEngine.resetStreamingState()
+
+                    speakerVerificationEngine = svEngine
+                    setSpeakerGateState(enabled: true, open: false)
+                    tapBufferSize = AVAudioFrameCount(max(64, svConfig.frameSize))
+                    NSLog("[STT] Speaker verification gate enabled frameSize=\(svConfig.frameSize) tailSeconds=\(svConfig.tailSeconds) threshold=\(svConfig.decisionThreshold) hangover=\(useSpeakerGateHangover ? "ON" : "OFF") hangSec=\(String(format: "%.3f", speakerGateHangoverSeconds))")
+                    if routeSampleRate != svConfig.sampleRate {
+                        NSLog("[STT] SV resampling enabled \(routeSampleRate)Hz -> \(svConfig.sampleRate)Hz")
+                    } else {
+                        NSLog("[STT] SV sampleRate already matched at \(routeSampleRate)Hz")
+                    }
+                } catch {
+                    speakerVerificationEngine = nil
+                    speakerVerificationThreshold = 0
+                    speakerVerificationFrameSeq = 0
+                    speakerVerificationSourceSampleRate = 0
+                    speakerVerificationTargetSampleRate = 0
+                    speakerVerificationResampleCarry.removeAll(keepingCapacity: false)
+                    speakerVerificationResamplePos = 0
+                    speakerLastPositiveMatchAt = 0
+                    setSpeakerGateState(enabled: false, open: true)
+                    speakerPreRollBuffers.removeAll(keepingCapacity: false)
+                    speakerPreRollFrames = 0
+                    speakerPreRollMaxFrames = 0
+                    speakerPendingPreRollFlush = false
+                    sendResult(error: ["message": "Speaker verification disabled: \(error.localizedDescription)"],
+                               bestTranscription: nil,
+                               transcriptions: nil,
+                               isFinal: nil)
+                }
+            }
+
+            inputNode.installTap(onBus: 0, bufferSize: tapBufferSize, format: format) { [weak self] buffer, _ in
                 // Strongify self once
                 guard let self = self else { return }
                 // ✅ Count frames globally so the watchdog can see forward progress
@@ -2192,8 +2482,24 @@ if let player = playbackNode {
                 let value = self.averagePowerForChannel1
                 self.sendEvent(name: "onSpeechVolumeChanged", body: ["value": value])
 
+                if self.currentSpeakerGateState().enabled, let ch0 = buffer.floatChannelData?[0] {
+                    let mono = Array(UnsafeBufferPointer(start: ch0, count: Int(buffer.frameLength)))
+                    self.processSpeakerVerificationSamples(mono)
+                }
+
                 // Append to recognition
-                self.recognitionRequest?.append(buffer)
+                let gate = self.currentSpeakerGateState()
+                if !gate.enabled {
+                    self.recognitionRequest?.append(buffer)
+                    NSLog("[STT][SV][TAP] samples=\(buffer.frameLength) gate=DISABLED action=append")
+                } else if gate.open {
+                    self.flushSpeakerPreRollIfNeeded()
+                    self.recognitionRequest?.append(buffer)
+                    NSLog("[STT][SV][TAP] samples=\(buffer.frameLength) gate=OPEN action=append preRollFrames=\(self.currentSpeakerPreRollFrames())")
+                } else {
+                    self.enqueueSpeakerPreRoll(buffer)
+                    NSLog("[STT][SV][TAP] samples=\(buffer.frameLength) gate=CLOSED action=buffer preRollFrames=\(self.currentSpeakerPreRollFrames())")
+                }
 
                 // inside inputNode.installTap { buffer, _ in
                 self.lastBufferAt = CACurrentMediaTime()
@@ -2205,6 +2511,8 @@ if let player = playbackNode {
             do {
                 try engine.start()
                 armFirstIOCycleLatch(on: engine)
+                reconcileAEC(on: engine, reason: "setup-start-poststart", allowRebuild: false)
+                scheduleAECReconcileRetries(reason: "setup-start")
             } catch {
                 audioSessionError = error as NSError
             }
@@ -2251,6 +2559,236 @@ if let player = playbackNode {
         }
     }
 
+    private func loadSpeakerVerificationStartConfig(onboardingJsonPath: String) throws -> SpeakerVerificationStartConfig {
+        let data = try Data(contentsOf: URL(fileURLWithPath: onboardingJsonPath))
+        let enrollment = try SpeakerEnrollment.deserialize(data)
+        return SpeakerVerificationStartConfig(enrollment: enrollment, config: enrollment.configSnapshot)
+    }
+
+    private func currentSpeakerGateState() -> (enabled: Bool, open: Bool) {
+        speakerVerificationStateLock.lock()
+        let state = (speakerGateEnabled, speakerGateOpen)
+        speakerVerificationStateLock.unlock()
+        return state
+    }
+
+    private func setSpeakerGateState(enabled: Bool, open: Bool) {
+        speakerVerificationStateLock.lock()
+        let wasOpen = speakerGateOpen
+        let wasEnabled = speakerGateEnabled
+        speakerGateEnabled = enabled
+        speakerGateOpen = open
+        let changed = (wasOpen != open) || (wasEnabled != enabled)
+        if enabled && open && (!wasEnabled || !wasOpen) {
+            speakerPendingPreRollFlush = true
+        }
+        if !enabled {
+            speakerPendingPreRollFlush = false
+        }
+        speakerVerificationStateLock.unlock()
+        if changed {
+            NSLog("[STT][SV][GATE] enabled=\(enabled ? "YES" : "NO") open=\(open ? "YES" : "NO") th=\(speakerVerificationThreshold)")
+        }
+    }
+
+    private func currentSpeakerPreRollFrames() -> Int {
+        speakerVerificationStateLock.lock()
+        let n = speakerPreRollFrames
+        speakerVerificationStateLock.unlock()
+        return n
+    }
+
+    private func enqueueSpeakerPreRoll(_ buffer: AVAudioPCMBuffer) {
+        speakerVerificationStateLock.lock()
+        defer { speakerVerificationStateLock.unlock() }
+        guard speakerPreRollMaxFrames > 0 else { return }
+        guard let copy = copyPCMBuffer(buffer) else { return }
+        speakerPreRollBuffers.append(copy)
+        speakerPreRollFrames += Int(copy.frameLength)
+
+        while speakerPreRollFrames > speakerPreRollMaxFrames, !speakerPreRollBuffers.isEmpty {
+            let dropped = speakerPreRollBuffers.removeFirst()
+            speakerPreRollFrames -= Int(dropped.frameLength)
+        }
+    }
+
+    private func flushSpeakerPreRollIfNeeded() {
+        var toFlush: [AVAudioPCMBuffer] = []
+        var totalFrames = 0
+        var selectedFrames = 0
+        speakerVerificationStateLock.lock()
+        if speakerPendingPreRollFlush {
+            totalFrames = speakerPreRollFrames
+            if useLegacySpeakerGateBehavior {
+                toFlush = speakerPreRollBuffers
+            } else {
+                let sr = max(1, speakerVerificationSourceSampleRate)
+                let maxFrames = max(1, Int(round(Double(sr) * speakerPreRollFlushMaxSeconds)))
+                if totalFrames <= maxFrames {
+                    toFlush = speakerPreRollBuffers
+                } else {
+                    var kept: [AVAudioPCMBuffer] = []
+                    var keptFrames = 0
+                    for b in speakerPreRollBuffers.reversed() {
+                        kept.append(b)
+                        keptFrames += Int(b.frameLength)
+                        if keptFrames >= maxFrames { break }
+                    }
+                    toFlush = kept.reversed()
+                }
+            }
+            selectedFrames = toFlush.reduce(0) { $0 + Int($1.frameLength) }
+            speakerPreRollBuffers.removeAll(keepingCapacity: false)
+            speakerPreRollFrames = 0
+            speakerPendingPreRollFlush = false
+        }
+        speakerVerificationStateLock.unlock()
+
+        if toFlush.isEmpty { return }
+        NSLog("[STT][SV][PREROLL] flushing buffers=\(toFlush.count) frames=\(selectedFrames) totalBuffered=\(totalFrames)")
+        for b in toFlush {
+            recognitionRequest?.append(b)
+        }
+    }
+
+    private func copyPCMBuffer(_ source: AVAudioPCMBuffer) -> AVAudioPCMBuffer? {
+        guard let dst = AVAudioPCMBuffer(pcmFormat: source.format, frameCapacity: source.frameLength) else {
+            return nil
+        }
+        dst.frameLength = source.frameLength
+        let channels = Int(source.format.channelCount)
+        let frames = Int(source.frameLength)
+
+        if let src = source.floatChannelData, let out = dst.floatChannelData {
+            let bytes = frames * MemoryLayout<Float>.size
+            for ch in 0..<channels {
+                memcpy(out[ch], src[ch], bytes)
+            }
+            return dst
+        }
+
+        if let src = source.int16ChannelData, let out = dst.int16ChannelData {
+            let bytes = frames * MemoryLayout<Int16>.size
+            for ch in 0..<channels {
+                memcpy(out[ch], src[ch], bytes)
+            }
+            return dst
+        }
+
+        if let src = source.int32ChannelData, let out = dst.int32ChannelData {
+            let bytes = frames * MemoryLayout<Int32>.size
+            for ch in 0..<channels {
+                memcpy(out[ch], src[ch], bytes)
+            }
+            return dst
+        }
+
+        return nil
+    }
+
+    private func resampleSamplesForSpeakerVerificationIfNeeded(_ input: [Float]) -> [Float] {
+        guard !input.isEmpty else { return [] }
+        let srcRate = speakerVerificationSourceSampleRate
+        let dstRate = speakerVerificationTargetSampleRate
+        guard srcRate > 0, dstRate > 0 else { return input }
+        if srcRate == dstRate { return input }
+
+        let ratio = Double(srcRate) / Double(dstRate) // source samples per output sample
+        let source = speakerVerificationResampleCarry + input
+        guard source.count >= 2 else {
+            speakerVerificationResampleCarry = source
+            return []
+        }
+
+        var out: [Float] = []
+        out.reserveCapacity(Int(Double(input.count) * Double(dstRate) / Double(srcRate)) + 8)
+
+        var pos = speakerVerificationResamplePos
+        while pos + 1.0 < Double(source.count) {
+            let i = Int(pos)
+            let frac = Float(pos - Double(i))
+            let a = source[i]
+            let b = source[i + 1]
+            out.append(a + (b - a) * frac)
+            pos += ratio
+        }
+
+        let keepStart = max(0, Int(floor(pos)) - 1)
+        speakerVerificationResampleCarry = Array(source[keepStart...])
+        speakerVerificationResamplePos = pos - Double(keepStart)
+        return out
+    }
+
+    private func processSpeakerVerificationSamples(_ samples: [Float]) {
+        guard !samples.isEmpty else { return }
+        speakerVerificationQueue.async { [weak self] in
+            guard let self = self else { return }
+            guard let engine = self.speakerVerificationEngine else { return }
+            let frameSize = self.speakerVerificationFrameSize
+            guard frameSize > 0 else { return }
+
+            let normalized = self.resampleSamplesForSpeakerVerificationIfNeeded(samples)
+            if normalized.isEmpty { return }
+            self.speakerVerificationInputBuffer.append(contentsOf: normalized)
+
+            while self.speakerVerificationInputBuffer.count >= frameSize {
+                let frame = Array(self.speakerVerificationInputBuffer.prefix(frameSize))
+                self.speakerVerificationInputBuffer.removeFirst(frameSize)
+                self.speakerVerificationFrameSeq &+= 1
+                let seq = self.speakerVerificationFrameSeq
+
+                do {
+                    let out = try engine.processFrame(frame: frame)
+                    switch out {
+                    case .pending(let p):
+                        let gate = self.currentSpeakerGateState()
+                        NSLog("[STT][SV][FRAME #\(seq)] pending buffered=\(p.bufferedSamples) neededSec=\(p.neededSeconds) gate=\(gate.open ? "OPEN" : "CLOSED") th=\(self.speakerVerificationThreshold)")
+                    case .result(let result):
+                        if self.useLegacySpeakerGateBehavior || !self.useSpeakerGateHangover {
+                            self.setSpeakerGateState(enabled: true, open: result.isMatch)
+                        } else {
+                            let now = CACurrentMediaTime()
+                            if result.isMatch {
+                                self.speakerLastPositiveMatchAt = now
+                                self.setSpeakerGateState(enabled: true, open: true)
+                            } else {
+                                let keepOpen = self.speakerLastPositiveMatchAt > 0 &&
+                                    (now - self.speakerLastPositiveMatchAt) <= max(0, self.speakerGateHangoverSeconds)
+                                self.setSpeakerGateState(enabled: true, open: keepOpen)
+                            }
+                        }
+                        let gate = self.currentSpeakerGateState()
+                        NSLog("[STT][SV][FRAME #\(seq)] scoreBest=\(String(format: "%.4f", result.scoreBest)) raw=\(String(format: "%.4f", result.scoreBestRaw)) meancombo=\(String(format: "%.4f", result.scoreBestMeancombo)) mean=\(String(format: "%.4f", result.scoreMean)) match=\(result.isMatch ? "YES" : "NO") gate=\(gate.open ? "OPEN" : "CLOSED") th=\(String(format: "%.4f", self.speakerVerificationThreshold)) hangover=\(self.useSpeakerGateHangover ? "ON" : "OFF") hangSec=\(String(format: "%.3f", self.speakerGateHangoverSeconds))")
+                    }
+                } catch {
+                    self.speakerVerificationEngine = nil
+                    self.speakerVerificationInputBuffer.removeAll(keepingCapacity: false)
+                    self.speakerVerificationSourceSampleRate = 0
+                    self.speakerVerificationTargetSampleRate = 0
+                    self.speakerVerificationResampleCarry.removeAll(keepingCapacity: false)
+                    self.speakerVerificationResamplePos = 0
+                    self.speakerLastPositiveMatchAt = 0
+                    self.setSpeakerGateState(enabled: false, open: true)
+                    self.speakerVerificationStateLock.lock()
+                    self.speakerPreRollBuffers.removeAll(keepingCapacity: false)
+                    self.speakerPreRollFrames = 0
+                    self.speakerPreRollMaxFrames = 0
+                    self.speakerVerificationStateLock.unlock()
+                    if !self.speakerVerificationErrorSent {
+                        self.speakerVerificationErrorSent = true
+                        DispatchQueue.main.async { [weak self] in
+                            self?.sendResult(error: ["message": "Speaker verification stopped: \(error.localizedDescription)"],
+                                             bestTranscription: nil,
+                                             transcriptions: nil,
+                                             isFinal: nil)
+                        }
+                    }
+                    return
+                }
+            }
+        }
+    }
+
     // MARK: - Helpers
     private func _normalizedPowerLevelFromDecibels(_ decibels: CGFloat) -> CGFloat {
         if decibels < -80.0 || decibels == 0.0 { return 0.0 }