react-native-davoice-tts 1.0.305 → 1.0.307

package/ios/TTSRNBridge/DavoiceTTS.xcframework/ios-arm64/DavoiceTTS.framework/DaVoiceSTT.swift.AEC.CRASH.ETC

@@ -1,2853 +0,0 @@
-// STT.swift
-// Native iOS Swift version (AEC flow preserved 1:1)
-
-import Foundation
-import UIKit
-import Speech
-import Accelerate
-import AVFAudio   // or import AVFoundation
-
-@objc public protocol STTDelegate: AnyObject {
-    @objc func stt(_ stt: STT, didEmitEvent name: String, body: [String: Any]?)
-}
-
-@objcMembers
-public final class STT: NSObject, SFSpeechRecognizerDelegate {
-    public weak var delegate: STTDelegate?
-    public var continuous: Bool = true
-
-    // 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?
-    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
-    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?
-    private var averagePowerForChannel0: Float = 0
-    private var averagePowerForChannel1: Float = 0
-    // Add to STT
-    private var isAdjustingRoute = false
-    private var lastRouteSignature: String = ""
-
-    private var playbackNode: AVAudioPlayerNode?
-    private var seenRealSpeech = false            // flips true after first non-blank token
-    private var engineHotAt: CFTimeInterval = 0   // when engine actually started
-    private let warmupKeepAlive: CFTimeInterval = 4.0 // seconds we’ll keep re-arming in silence
-
-    // Keep-engine-alive helpers
-    private var lastReclaimAttempt: CFAbsoluteTime = 0
-    private let reclaimCooldown: CFTimeInterval = 1.0
-
-    // Serialize pause/unpause (and their waits)
-    private let micPauseLock = NSRecursiveLock()
-
-    // --- Task health ---
-    private var lastBufferAt: CFTimeInterval = 0       // updated from tap
-    private var lastResultAt: CFTimeInterval = 0       // updated from recognition callback
-    private var lastTaskStartAt: CFTimeInterval = 0
-    private var stallWatchdog: Timer?
-    private var consecutiveStallCount = 0
-    private let stallThreshold: CFTimeInterval = 8.0   // seconds w/o results while engine is hot
-    private let rearmCooldownTask: CFTimeInterval = 2.0
-    private var lastRearmAt: CFTimeInterval = 0
-    private var engineHot = false
-    private var hotAt: CFTimeInterval = 0
-    private var lastLocaleStr: String = ""
-    // --- Recovery & diagnostics ---
-    private var recoverySeq = 0
-    private var lastRecoveryAt: CFTimeInterval = 0
-    private var lastTaskOrigin: String = "cold"
-    private var savedSessionBeforePause: (
-        category: AVAudioSession.Category,
-        mode: AVAudioSession.Mode,
-        options: AVAudioSession.CategoryOptions,
-        sr: Double,
-        inCh: Int,
-        outCh: Int,
-        ioDur: TimeInterval
-    )?
-
-    private(set) var sttActive = false
-    // STT.swift  (add near `private var playbackNode: AVAudioPlayerNode?`)
-//    private var ttsEQ: AVAudioUnitEQ?
-
-    // Add near your other state:
-    private var ioLatchActiveGen: UInt64 = 0
-
-    // TTS probe state
-    private var mixerProbeActive = false
-    private var mixerProbeCompletions: [(Bool) -> Void] = []
-    private let ttsSerial = DispatchQueue(label: "stt.tts.serial") // serialize TTS schedule/play
-    private var engineHasRenderedOnce = false
-
-    private var tapFramesTotal: UInt64 = 0          // monotonically increases inside input tap
-    private var lastTapFramesSeen: UInt64 = 0       // snapshot seen by watchdog
-    private var lastNoInputRecoveryAt: CFTimeInterval = 0
-    private var consecutiveNoInputResets = 0
-    // thresholds / cool-downs
-    private let noInputThreshold: CFTimeInterval = 1.0    // seconds without any buffers
-    private let noInputCooldown:   CFTimeInterval = 5.0    // avoid thrashing recoveries
-    private let maxGentleRetries   = 2                     // try start() a couple times before rebuild
-    private var isTelephonyInterrupted = false
-    private var isRecoveringAfterTelephony = false   // NEW
-    // MARK: - Post-telephony recognition kick
-    private var startedRecognitionAfterCall = false
-    // Add near other state:
-    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
-        speechRecognitionPaused = false
-        speechPauseLock.unlock()
-        NSLog("[STT] resetSpeechRecognitionLitePauseState(\(why)) -> count=0 paused=NO")
-    }
-
-    // MARK: - Event names (unchanged)
-    public static let supportedEvents: [String] = [
-        "onSpeechResults",
-        "onSpeechStart",
-        "onSpeechPartialResults",
-        "onSpeechError",
-        "onSpeechEnd",
-        "onSpeechRecognized",
-        "onSpeechVolumeChanged"
-    ]
-    private func removeEngineObservers() {
-    let nc = NotificationCenter.default
-    if let engine = audioEngine {
-        nc.removeObserver(self,
-                          name: .AVAudioEngineConfigurationChange,
-                          object: engine)
-    }
-    nc.removeObserver(self,
-                      name: AVAudioSession.interruptionNotification,
-                      object: AVAudioSession.sharedInstance())
-    nc.removeObserver(self,
-                      name: AVAudioSession.routeChangeNotification,
-                      object: AVAudioSession.sharedInstance())
-    nc.removeObserver(self,
-                      name: AVAudioSession.mediaServicesWereResetNotification,
-                      object: nil)
-}
-
-private func hasExternalOutput(_ s: AVAudioSession) -> Bool {
-    return s.currentRoute.outputs.contains {
-        switch $0.portType {
-        case .headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .airPlay, .carAudio, .usbAudio:
-            return true
-        default:
-            return false
-        }
-    }
-}
-
-// Force loudspeaker if iOS routes to receiver while we want speaker.
-private func forceSpeakerIfReceiver(_ why: String) {
-    let s = AVAudioSession.sharedInstance()
-
-    // If there is ANY external output, never fight it.
-    if hasExternalOutput(s) { return }
-
-    let isReceiver = s.currentRoute.outputs.contains { $0.portType == .builtInReceiver }
-    if !isReceiver { return }
-
-    do {
-        try s.overrideOutputAudioPort(.speaker)
-        NSLog("[STT] 🔊 forceSpeakerIfReceiver(\(why)): receiver -> speaker")
-    } catch {
-        NSLog("[STT] 🔊 forceSpeakerIfReceiver(\(why)) failed: \(error.localizedDescription)")
-    }
-}
-
-private func stopRecognitionTaskLite(_ why: String) {
-    // Don't fight teardown / telephony / mic pause.
-    if isTearingDown || isTelephonyInterrupted || isRecoveringAfterTelephony || micPaused { return }
-
-    if recognitionTask != nil || recognitionRequest != nil {
-        NSLog("[STT] stopRecognitionTaskLite(\(why)) cancel+drop req/task")
-    }
-
-    recognitionTask?.cancel()
-    recognitionTask = nil
-
-    recognitionRequest?.endAudio()
-    recognitionRequest = nil
-
-    // reset "speech started" gating so we emit cleanly after resume
-    seenRealSpeech = false
-}
-
-@objc public func pauseSpeechRecognitionLite() {
-    // Update counter under lock
-    if isTearingDown || isTelephonyInterrupted || isRecoveringAfterTelephony || micPaused { return }
-
-    speechPauseLock.lock()
-    let wasZero = (speechRecognitionPauseCount == 0)
-    speechRecognitionPauseCount += 1
-    speechRecognitionPaused = true
-    let c = speechRecognitionPauseCount
-    speechPauseLock.unlock()
-
-    NSLog("[STT] pauseSpeechRecognitionLite(): count=\(c) (speechRecognitionPaused=YES)")
-
-    // Only act on the FIRST pause (0->1)
-    guard wasZero else { return }
-
-    // Lite behavior: cancel current speech task & drop request so buffers stop accumulating
-    DispatchQueue.main.async { [weak self] in
-        guard let self = self else { return }
-
-        // Only if STT is actually active and mic is not paused
-        if !self.sttActive { NSLog("[STT] pauseSpeechRecognitionLite: ignored (sttActive=NO)"); return }
-        if self.micPaused { NSLog("[STT] pauseSpeechRecognitionLite: ignored (micPaused=YES)"); return }
-
-        self.stopRecognitionTaskLite("lite-pause")
-    }
-}
-
-// NEW: times == -1 => clear all pauses (force resume)
-//      times >= 1  => decrement by N
-@objc public func unPauseSpeechRecognitionLite(_ times: NSNumber) {
-    let n = times.intValue
-
-    speechPauseLock.lock()
-    if n == -1 {
-        speechRecognitionPauseCount = 0
-    } else if n > 0 {
-        speechRecognitionPauseCount = max(0, speechRecognitionPauseCount - n)
-    } else {
-        // 0 or weird negatives (except -1): do nothing
-    }
-
-    let reachedZero = (speechRecognitionPauseCount == 0)
-    if reachedZero { speechRecognitionPaused = false }
-
-    let c = speechRecognitionPauseCount
-    let paused = speechRecognitionPaused
-    speechPauseLock.unlock()
-
-    NSLog("[STT] unPauseSpeechRecognitionLite(times=\(n)): count=\(c) (speechRecognitionPaused=\(paused ? "YES" : "NO"))")
-
-    guard reachedZero else { return }
-
-    DispatchQueue.main.async { [weak self] in
-        guard let self = self else { return }
-
-        // Conditions you asked for
-        if self.isTearingDown { NSLog("[STT] lite-unpause: ignored (isTearingDown=YES)"); return }
-        if self.isTelephonyInterrupted || self.isRecoveringAfterTelephony {
-            NSLog("[STT] lite-unpause: ignored (telephony/recovering)")
-            return
-        }
-        if !self.sttActive { NSLog("[STT] lite-unpause: ignored (sttActive=NO)"); return }
-        if self.micPaused { NSLog("[STT] lite-unpause: ignored (micPaused=YES)"); return }
-
-        // If we don't currently have a task, create a FRESH request/task.
-        // Use your existing engine/task bring-up logic (keeps it “lite”).
-        self.ensureEngineRunning(reason: "lite-unpause", skipCooldown: true)
-
-        // Extra defensive: if engine is running but task didn't start, force a fresh task.
-        if self.recognitionTask == nil {
-            self.startTask(self.makeFreshRequest())
-            NSLog("[STT] lite-unpause: forced startTask(makeFreshRequest())")
-        }
-    }
-}
-
-@objc public func pauseMicrophoneAndWait(_ timeoutMs: NSNumber,
-                                        completion: @escaping (Bool, String?) -> Void) {
-    micPauseLock.lock()
-
-    // If already paused, just wait for settle condition (idempotent)
-    if !micPaused {
-        pauseMicrophone()
-    }
-
-    let timeoutSec = max(0.1, timeoutMs.doubleValue / 1000.0)
-
-    pollOnMain(timeoutSec: timeoutSec, intervalSec: 0.05,
-               condition: { [weak self] in
-                    guard let self = self else { return false }
-                    return self.isPausedSettled()
-               },
-               done: { [weak self] ok in
-                    // IMPORTANT: unlock BEFORE calling completion (completion may call pause/unpause again)
-                    self?.micPauseLock.unlock()
-                    completion(ok, ok ? nil : "pause_timeout")
-               })
-}
-
-@objc public func unPauseMicrophoneAndWait(_ timeoutMs: NSNumber,
-                                          completion: @escaping (Bool, String?) -> Void) {
-    micPauseLock.lock()
-
-    // If not paused, still ensure we're “live” (idempotent)
-    if micPaused {
-        unPauseMicrophone()
-    }
-
-    let timeoutSec = max(0.1, timeoutMs.doubleValue / 1000.0)
-
-    pollOnMain(timeoutSec: timeoutSec, intervalSec: 0.05,
-               condition: { [weak self] in
-                    guard let self = self else { return false }
-                    return self.isUnpausedSettled()
-               },
-               done: { [weak self] ok in
-                    self?.micPauseLock.unlock()
-                    completion(ok, ok ? nil : "unpause_timeout")
-               })
-}
-
-// MARK: - settle conditions
-
-private func isPausedSettled() -> Bool {
-    let s = AVAudioSession.sharedInstance()
-
-    // What "settled" means for PAUSE in your implementation:
-    // - micPaused flag latched
-    // - engine + task gone
-    // - session in playback
-    // - no input ports visible
-    if micPaused != true { return false }
-    if audioEngine != nil { return false }
-    if recognitionTask != nil { return false }
-    if recognitionRequest != nil { return false }
-    if s.category != .playback { return false }
-    if !s.currentRoute.inputs.isEmpty { return false }
-
-    return true
-}
-
-private func isUnpausedSettled() -> Bool {
-    let s = AVAudioSession.sharedInstance()
-
-    // What "settled" means for UNPAUSE:
-    // - micPaused false
-    // - engine running
-    // - recognitionTask exists + running
-    // - request exists
-    // - capture is valid
-    if micPaused != false { return false }
-    guard let eng = audioEngine, eng.isRunning else { return false }
-    guard let task = recognitionTask, task.state == .running else { return false }
-    guard recognitionRequest != nil else { return false }
-    if s.category != .playAndRecord { return false }
-    if !hasValidCaptureNow(allowColdEngine: true) { return false }
-
-    return true
-}
-
-// MARK: - polling helper (MAIN QUEUE)
-
-private func pollOnMain(timeoutSec: TimeInterval,
-                        intervalSec: TimeInterval,
-                        condition: @escaping () -> Bool,
-                        done: @escaping (Bool) -> Void) {
-    let deadline = CACurrentMediaTime() + timeoutSec
-
-    func step() {
-        // Always on main
-        if condition() {
-            done(true)
-            return
-        }
-        if CACurrentMediaTime() >= deadline {
-            done(false)
-            return
-        }
-        DispatchQueue.main.asyncAfter(deadline: .now() + intervalSec) {
-            step()
-        }
-    }
-
-    DispatchQueue.main.async {
-        step()
-    }
-}
-
-    public func pauseMicrophone() {
-        NSLog("[STT] pauseMicrophone() requested")
-        
-        // ✅ HARD reset speech-lite pause state on mic pause
-        resetSpeechRecognitionLitePauseState("pauseMicrophone")
-
-        guard !micPaused else {
-            NSLog("[STT] pauseMicrophone(): already paused")
-            return
-        }
-        micPaused = true
-
-        let session = AVAudioSession.sharedInstance()
-
-        // Save current session config (so we can restore on unpause)
-        if savedSessionBeforePause == nil {
-            let sr   = session.sampleRate
-            let inCh = Int(session.inputNumberOfChannels)
-            let outCh = Int(session.outputNumberOfChannels)
-            let ioDur = session.ioBufferDuration
-
-            savedSessionBeforePause = (
-                category: session.category,
-                mode: session.mode,
-                options: session.categoryOptions,
-                sr: sr,
-                inCh: inCh,
-                outCh: outCh,
-                ioDur: ioDur
-            )
-        }
-        // Watchdog is pointless while paused (and would try to “heal” us)
-        stopWatchdog()
-
-        // Stop mic capture but keep TTS safe — remove taps first
-        if let eng = audioEngine {
-            safeRemoveTap(eng.inputNode)
-            safeRemoveTap(eng.mainMixerNode)
-            safeRemoveTap(eng.outputNode)
-        }
-        // 🔴 NEW: fully stop and tear down the engine so session can really deactivate
-        if let eng = audioEngine {
-            if eng.isRunning {
-                eng.stop()
-            }
-            eng.reset()
-        }
-        audioEngine = nil
-
-        // Clear playback node in this engine; unpause will rebuild a fresh engine+player graph
-        if let p = playbackNode {
-            p.stop()
-        }
-        playbackNode = nil
-
-        // Clear AudioPlaybackHook engine-based callbacks (defensive)
-        AudioPlaybackHook.currentEngine = nil
-        AudioPlaybackHook.engineScheduleFile = nil
-        AudioPlaybackHook.isEngineReady = nil
-        AudioPlaybackHook.useOnlyEnginePlayback = nil
-        AudioPlaybackHook.stopEnginePlayback = nil
-
-        // Stop recognition cleanly (we'll re-create on unpause)
-        recognitionTask?.cancel()
-        recognitionTask = nil
-        recognitionRequest?.endAudio()
-        recognitionRequest = nil
-
-        // Switch to playback-only session so iOS releases the mic (indicator off)
-        do {
-            // 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)")
-        }
-        // Switch to playback-only session so iOS releases the mic (indicator off)
-        do {
-            try session.setCategory(.playback, options: [/*.mixWithOthers*/])
-            NSLog("[STT] pauseMicrophone(): session set to .playback (mic released)")
-        } catch {
-            NSLog("[STT] pauseMicrophone(): failed to switch to .playback: \(error.localizedDescription)")
-        }
-        // 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)")
-        }
-    }
-
-    public func unPauseMicrophone() {
-        NSLog("[STT] unPauseMicrophone() requested")
-        guard micPaused else {
-            NSLog("[STT] unPauseMicrophone(): not paused")
-            return
-        }
-        // ✅ HARD reset speech-lite pause state on mic unpause
-        resetSpeechRecognitionLitePauseState("unPauseMicrophone")
-
-        let session = AVAudioSession.sharedInstance()
-
-        if let saved = savedSessionBeforePause {
-            // 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)")
-            }
-
-            do {
-                try session.setCategory(saved.category,
-                                        mode: saved.mode,
-                                        options: saved.options)
-            } catch {
-                NSLog("[STT] unPauseMicrophone: restoring category failed: \(error.localizedDescription)")
-            }
-
-            if saved.sr > 0 {
-                try? session.setPreferredSampleRate(saved.sr)
-            }
-            if saved.inCh > 0 && session.isInputAvailable {
-                try? session.setPreferredInputNumberOfChannels(saved.inCh)
-            }
-            if saved.outCh > 0 {
-                try? session.setPreferredOutputNumberOfChannels(saved.outCh)
-            }
-            if saved.ioDur > 0 {
-                try? session.setPreferredIOBufferDuration(saved.ioDur)
-            }
-
-            do {
-                try session.setActive(true, options: [])
-                markAECSessionActivation(true, reason: "unPauseMicrophone")
-            } catch {
-                NSLog("[STT] unPauseMicrophone: setActive(true) failed: \(error.localizedDescription)")
-            }
-            _ = setupAudioSession()
-            
-            // !!! IMPORTANT if micPaused = true then rebuildEngineGraphAndRestart will not activate necessary things!
-            micPaused = false
-            // Rebuild graph + reinstall tap + restart recognition
-            rebuildEngineGraphAndRestart(reason: "unpause-mic")
-            NSLog("[STT] unPauseMicrophone(): session restored + rebuildEngineGraphAndRestart() called")
-            startWatchdog()
-
-            // Clear so next pause re-snapshots the current config
-            savedSessionBeforePause = nil
-        } else {
-            // Fallback if we never saved a session (very defensive)
-            NSLog("[STT] unPauseMicrophone(): no savedSessionBeforePause, using setupAudioSession()")
-            _ = setupAudioSession()
-            rebuildEngineGraphAndRestart(reason: "unpause-mic-nosaved")
-            startWatchdog()
-        }
-        micPaused = false
-    }
-
-    private var graphGen: UInt64 = 0
-    @inline(__always) private func bumpGraphGen() { graphGen &+= 1; ioLatchActiveGen = 0 }
-    // Add near other state
-    private var pausedForCaptureLoss = false
-
-    private func markCaptureLost() {
-        pausedForCaptureLoss = true
-    }
-
-    private func tryClearCaptureLossAfterStartSucceeded() {
-        // Only clear after we actually start the engine
-        pausedForCaptureLoss = false
-    }
-
-    // MARK: - AEC Toggle API
-
-    /// Enable/disable iOS voice-processing (AEC + ducking).
-    /// If STT is already active, we rebuild the session/graph so it takes effect.
-    public func setAECEnabled(_ enabled: Bool) {
-        NSLog("[STT] setAECEnabled(\(enabled))")
-        aecEnabled = enabled
-
-        // If recognition is live, re-apply session + graph so change is effective
-        if sttActive {
-            _ = setupAudioSession()
-            rebuildEngineGraphAndRestart(reason: enabled ? "aec-on" : "aec-off")
-        }
-    }
-
-    public func isAECEnabled() -> Bool {
-        return aecEnabled
-    }
-
-    private func startRecognitionAfterCall() {
-        guard !startedRecognitionAfterCall else { return }
-        startedRecognitionAfterCall = true
-
-        // The local speech daemon can be in a funky state after telephony.
-        recreateSpeechRecognizerPreservingLocale()
-
-        let req = makeFreshRequest()
-        startTask(req)
-
-        // Recovery window ends only after we have a live task
-        isRecoveringAfterTelephony = false
-        startWatchdog() // resume health checks now that we're live again
-        NSLog("[STT] recovery: recognition task started after buffers observed")
-    }
-
-    private func hasValidCaptureNow(allowColdEngine: Bool = true) -> Bool {
-        let s = AVAudioSession.sharedInstance()
-
-        // Real “no mic” conditions (A2DP only, telephony, etc.)
-        guard s.isInputAvailable,
-            !s.currentRoute.inputs.isEmpty,
-            s.inputNumberOfChannels > 0,
-            s.sampleRate > 0 else { return false }
-
-        // If we require a hot engine, check the node *only when running*.
-        if !allowColdEngine, let eng = audioEngine, eng.isRunning {
-            let f = eng.inputNode.outputFormat(forBus: 0)
-            return f.sampleRate > 0 && f.channelCount > 0
-        }
-
-        // Session says we have input; engine may be cold — that’s fine to attempt start().
-        return true
-    }
-
- 
-    @inline(__always)
-    private func safeRemoveTap(_ node: AVAudioNode?, bus: AVAudioNodeBus = 0) {
-        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)
-
-    public func isSpeechAvailable(_ completion: @escaping (Bool) -> Void) {
-        SFSpeechRecognizer.requestAuthorization { status in
-            switch status {
-            case .authorized: completion(true)
-            default: completion(false)
-            }
-        }
-    }
-
-    private func armFirstIOCycleLatch(on engine: AVAudioEngine) {
-        engineHasRenderedOnce = false
-        let gen = graphGen
-
-        // Prevent overlapping latches against the same graph generation.
-        if ioLatchActiveGen == gen { return }
-        ioLatchActiveGen = gen
-
-        DispatchQueue.main.async { [weak self, weak engine] in
-            guard let self = self, let eng = engine, gen == self.graphGen else { return }
-            let out = eng.outputNode
-            var fired = false
-
-            // >>> IMPORTANT: ensure no previous tap is left behind
-            self.safeRemoveTap(out, bus: 0)
-
-            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
-                self.safeRemoveTap(out, bus: 0)
-                self.engineHasRenderedOnce = true
-                // latch finished for this gen
-                if self.ioLatchActiveGen == gen { self.ioLatchActiveGen = 0 }
-            }
-
-            DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { [weak self, weak out] in
-                guard let self = self, gen == self.graphGen else { return }
-                if fired { return }
-                self.safeRemoveTap(out, bus: 0)
-                self.engineHasRenderedOnce = true // fail-open
-                if self.ioLatchActiveGen == gen { self.ioLatchActiveGen = 0 }
-            }
-        }
-    }
-
-    public func isRecognizing() -> Bool {
-        guard let task = recognitionTask else { return false }
-        return task.state == .running
-    }
-
-    private func ensurePlaybackNode(in engine: AVAudioEngine) -> AVAudioPlayerNode {
-        if let p = playbackNode, p.engine === engine {
-            return p
-        }
-        let p = AVAudioPlayerNode()
-        playbackNode = p
-        engine.attach(p)
-
-//     // Ensure we have a de-esser on this engine (recreate if needed)
-//     if ttsEQ?.engine !== engine {
-//         if let old = ttsEQ, old.engine != nil {
-//             // Best-effort detach if old EQ belongs to a different engine
-//             // (safe even if already gone)
-//         }
-// // --- Aggressive low-pass only ---
-// let deEss = AVAudioUnitEQ(numberOfBands: 1)
-// let lpf = deEss.bands[0]
-// lpf.filterType = .lowPass
-// lpf.frequency  = 6500        // try 6000–7500
-// lpf.bandwidth  = 0.35        // fairly steep
-// lpf.gain       = 0.0
-// lpf.bypass     = false
-
-// self.ttsEQ = deEss
-
-//         ttsEQ = deEss
-//         engine.attach(deEss)
-//     }
-
-//     // Route: player -> EQ -> mainMixer
-//     if let deEss = ttsEQ {
-//         engine.disconnectNodeOutput(p)
-//         engine.connect(p, to: deEss, format: nil)
-//         engine.connect(deEss, to: engine.mainMixerNode, format: nil)
-//     } else {
-//         // ultra-defensive fallback
-//         engine.connect(p, to: engine.mainMixerNode, format: nil)
-//     }
-        engine.connect(p, to: engine.mainMixerNode, format: nil)
-        return p
-    }
-
-    private func startWatchdog() {
-        stallWatchdog?.invalidate()
-        stallWatchdog = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: true) { [weak self] _ in
-            self?.checkTaskHealth()
-        }
-        RunLoop.main.add(stallWatchdog!, forMode: .common)
-    }
-
-    private func stopWatchdog() {
-        stallWatchdog?.invalidate()
-        stallWatchdog = nil
-    }
-
-    private func rearmTask(reason: String) {
-        // Cancel old task only — keep the engine and tap running.
-        if isTelephonyInterrupted || isRecoveringAfterTelephony {
-            NSLog("[STT] rearmTask(\(reason)) suppressed (telephony/recovering)")
-            return
-        }
-        if micPaused {
-            NSLog("[STT] rearmTask(\(reason)) suppressed (micPaused)")
-            return
-        }
-        if isSpeechRecognitionLitePaused() {
-            NSLog("[STT] rearmTask(\(reason)) suppressed (speechRecognitionPaused)")
-            return
-        }
-
-        // -----------------
-        recognitionTask?.cancel()
-        recognitionTask = nil
-
-        seenRealSpeech = false
-        lastTaskStartAt = CACurrentMediaTime()
-        startTask(makeFreshRequest())
-        NSLog("[STT] rearmTask(\(reason)) -> new task started")
-    }
-
-private func checkTaskHealth() {
-    if isTearingDown || isTelephonyInterrupted || isRecoveringAfterTelephony { 
-        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
-    }
-
-    let now = CACurrentMediaTime()
-
-    // ⛳️ GRACE: don’t call "stall" right after a new task begins
-    if now - lastTaskStartAt < 5.0 { return }
-
-    // 0) No capture? Wait quietly.
-    if !hasValidCaptureNow(allowColdEngine: true) {
-        markCaptureLost()
-        NSLog("[STT] watchdog: capture not available; waiting…")
-        return
-    }
-
-    // 1) Engine down? Bring it up (bypass cooldown from watchdog).
-    if audioEngine == nil || !(audioEngine?.isRunning ?? false) {
-        NSLog("[STT] watchdog: engine down → ensureEngineRunning")
-        ensureEngineRunning(reason: "watchdog-engine-down", skipCooldown: true)
-        return
-    }
-
-    // 2) Recognizer unavailable? wait.
-    if let rec = speechRecognizer, rec.isAvailable == false {
-        NSLog("[STT] watchdog: recognizer unavailable; waiting…")
-        return
-    }
-
-    // 3) No task? start one.
-    if recognitionTask == nil {
-        if now - lastRearmAt > rearmCooldownTask {
-            lastRearmAt = now
-            startTask(makeFreshRequest())
-        }
-        return
-    }
-
-    // 4) No input buffers? gentle nudge, then rebuild if repeated.
-    let timeSinceBuffer = now - lastBufferAt
-    if timeSinceBuffer > noInputThreshold {
-        if now - lastNoInputRecoveryAt > noInputCooldown {
-            lastNoInputRecoveryAt = now
-            consecutiveNoInputResets += 1
-            ensureEngineRunning(reason: "watchdog-no-input", skipCooldown: true)
-            if consecutiveNoInputResets >= maxGentleRetries {
-                consecutiveNoInputResets = 0
-                rebuildEngineGraphAndRestart(reason: "watchdog-no-input-rebuild")
-            }
-        }
-        return
-    } else {
-        consecutiveNoInputResets = 0
-    }
-
-    // 5) Buffers flowing but no results → rearm task.
-    let noResultsFor = now - lastResultAt
-    if noResultsFor > stallThreshold {
-        if now - lastRearmAt > rearmCooldownTask {
-            lastRearmAt = now
-            consecutiveStallCount += 1
-            rearmTask(reason: "watchdog-stall")
-            if consecutiveStallCount >= 3 {
-                recreateSpeechRecognizerPreservingLocale()
-                consecutiveStallCount = 0
-            }
-        }
-    } else {
-        consecutiveStallCount = 0
-    }
-}
-
-    public func startSpeech(localeStr: String?) {
-        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)
-            return
-        }
-
-        SFSpeechRecognizer.requestAuthorization { [weak self] status in
-            guard let self = self else { return }
-            switch status {
-            case .notDetermined:
-                self.sendResult(error: ["message": "Speech recognition not yet authorized"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            case .denied:
-                self.sendResult(error: ["message": "User denied access to speech recognition"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            case .restricted:
-                self.sendResult(error: ["message": "Speech recognition restricted on this device"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            case .authorized:
-                self.setupAndStartRecognizing(localeStr: localeStr)
-            @unknown default:
-                self.sendResult(error: ["message": "Unknown authorization status"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            }
-        }
-    }
-
-    public func stopSpeech(_ completion: ((Bool) -> Void)? = nil) {
-        NSLog("[STT] stopSpeech() requested by app")
-        recognitionTask?.finish()
-        completion?(false)
-    }
-
-    public func cancelSpeech(_ completion: ((Bool) -> Void)? = nil) {
-        NSLog("[STT] cancelSpeech() requested by app")
-
-        recognitionTask?.cancel()
-        completion?(false)
-    }
-
-    public func destroySpeech(_ completion: ((Bool) -> Void)? = nil) {
-        NSLog("[STT] **** destroySpeech!!!")
-        teardown()
-        completion?(false)
-    }
-
-    private func updateSessionRouting(selectBestInput: Bool = true) {
-        NSLog("[STT] ⚠️ updateSessionRouting??? why???")
-
-        if isAdjustingRoute { return }
-
-        isAdjustingRoute = true
-        defer { isAdjustingRoute = false }
-
-        let s = AVAudioSession.sharedInstance()
-
-        let hasInputRoute = s.isInputAvailable && !s.currentRoute.inputs.isEmpty
-        if !hasInputRoute {
-            // Transient during category/route settle — do NOT bail.
-            NSLog("[STT] route: input not visible yet (transient) — proceeding to activate session")
-        }
-
-        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-            guard let self = self else { return }
-
-            let hasWiredOrCar = s.currentRoute.outputs.contains {
-                switch $0.portType {
-                case .headphones,
-                    .bluetoothA2DP,
-                    .bluetoothHFP,
-                    .bluetoothLE,
-                    .airPlay,
-                    .carAudio,
-                    .usbAudio:
-                    return true
-                default:
-                    return false
-                }
-            }
-            if selectBestInput, let all = s.availableInputs {
-                let btHFP = all.first { $0.portType == .bluetoothHFP || $0.portType == .bluetoothLE }
-                let wired = all.first { $0.portType == .headsetMic }
-                let built = all.first { $0.portType == .builtInMic }
-                //let best  = btHFP ?? wired ?? built
-                // Prefer BT HFP (mic), then wired mic; otherwise leave preferredInput as-is.
-                let desired = btHFP ?? wired
-
-                do {
-                    if let desired, s.preferredInput?.uid != desired.uid {
-                        try s.setPreferredInput(desired)
-                    } else if desired == nil {
-                        // No headset mic → clear preference; do NOT force built-in
-                        if s.preferredInput != nil { try s.setPreferredInput(nil) }
-                    }
-                    // If built-in is already what the system selected, we need no action.
-                    if let builtIn = built, (desired == nil), s.preferredInput?.uid == nil {
-                        // Optionally hint bottom/back data source, but don’t fight routes
-                        if let ds = builtIn.dataSources?.first(where: { $0.orientation == .bottom || $0.orientation == .back }) {
-                            try? builtIn.setPreferredDataSource(ds)
-                        }
-                    }
-                } catch {
-                    NSLog("[STT] setPreferredInput failed: \(error.localizedDescription)")
-                }            
-            }
-
-            var opts: AVAudioSession.CategoryOptions = [.allowBluetooth]
-            if !hasWiredOrCar { opts.insert(.defaultToSpeaker) }
-
-            if s.category != .playAndRecord || s.mode != .default || s.categoryOptions != opts {
-                do { try s.setCategory(.playAndRecord, mode: .default, options: opts) }
-                catch { NSLog("[STT] setCategory 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)
-            self.forceSpeakerIfReceiver("updateSessionRouting")
-
-            // Log route back on main so logs stay ordered
-            DispatchQueue.main.async {
-                let inPorts  = s.currentRoute.inputs.map { "\($0.portType.rawValue):\($0.portName)" }.joined(separator:", ")
-                let outPorts = s.currentRoute.outputs.map { "\($0.portType.rawValue):\($0.portName)" }.joined(separator:", ")
-                NSLog("[STT] route in=[\(inPorts)] out=[\(outPorts)]")
-            }
-        }
-    }
-
-    // ↓↓↓ 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:
-                return true
-            default: return false
-            }
-        }
-
-        let builtInOut = session.currentRoute.outputs.allSatisfy { $0.portType == .builtInSpeaker }
-        let builtInIn  = session.currentRoute.inputs.allSatisfy  { $0.portType == .builtInMic }
-
-        // Prefer 16k only on built-in mic+speaker (voice pipeline). Otherwise leave SR to route.
-        if builtInIn && builtInOut {
-            try? session.setPreferredSampleRate(16_000)
-            if session.isInputAvailable { try? session.setPreferredInputNumberOfChannels(1) }
-            // ⚠️ Do NOT force output channels to 1; many routes require 2ch.
-            // try? session.setPreferredOutputNumberOfChannels(1)  // ← REMOVE
-        } else {
-            // Input mono is generally OK, but don’t touch output channels
-            if session.isInputAvailable { try? session.setPreferredInputNumberOfChannels(1) }
-        }
-
-        // A small IO buffer is fine across routes
-        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).
-    /// Returns true if no errors occurred (identical flow & calls as ObjC) + keep-alive opts.
-    /// Returns true if no errors occurred (identical flow & calls as ObjC) + keep-alive opts.
-    private func setupAudioSession() -> Bool {
-        var err: NSError?
-        let session = AVAudioSession.sharedInstance()
-        self.audioSession = session
-
-        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)
-        let hasExternalOutput: Bool = session.currentRoute.outputs.contains {
-            switch $0.portType {
-            case .headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .airPlay, .carAudio, .usbAudio:
-                return true
-            default:
-                return false
-            }
-        }
-
-        var opts: AVAudioSession.CategoryOptions = [.allowBluetooth]
-        if !hasExternalOutput { opts.insert(.defaultToSpeaker) }
-        if #available(iOS 14.5, *) {
-            // Prevent muted switch / mic mute from killing our capture pipeline
-            opts.insert(.overrideMutedMicrophoneInterruption)
-        }
-        do {
-            try session.setCategory(.playAndRecord, mode: .default, options: opts)
-        } catch { err = error as NSError }
-
-        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)
-            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),
-              Int(session.outputNumberOfChannels))
-        force16kIfPossible(session)
-        forceSpeakerIfReceiver("setupAudioSession")
-
-        if let e = err {
-            NSLog("[STT] setupAudioSession error: \(e.localizedDescription)")
-            sendResult(error: ["code": "audio", "message": e.localizedDescription],
-                       bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            return false
-        }
-        
-        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)
-        if fmt.sampleRate > 0 && fmt.channelCount > 0 { return fmt }
-        // Fallback: build a sane mono format from session if ever needed.
-        let sr = max(8000, AVAudioSession.sharedInstance().sampleRate)
-        return AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: sr, channels: 1, interleaved: false)
-    }
-
-    private func isHeadsetPluggedIn() -> Bool {
-        let route = AVAudioSession.sharedInstance().currentRoute
-        for out in route.outputs {
-            if out.portType == .headphones || out.portType == .bluetoothA2DP {
-                return true
-            }
-        }
-        return false
-    }
-
-private func recoverAfterTelephonyInterruption() {
-    guard hasValidCaptureNow(allowColdEngine: true) else {
-        NSLog("[STT] recoverAfterTelephonyInterruption: no capture yet; will rely on watchdog/next route change")
-        return
-    }
-
-    bumpGraphGen()
-    NSLog("[STT] 🔄 recovering graph after telephony")
-
-    if audioEngine == nil { audioEngine = AVAudioEngine() }
-    AudioPlaybackHook.currentEngine = { [weak self] in self?.audioEngine }  // ⬅️ add this
-    guard let eng = audioEngine else { return }
-    installEngineObservers()
-
-    _ = setupAudioSession()                          // ✅ ensures correct mode/options
-    forceSpeakerIfReceiver("recoverAfterTelephony")  // ✅ receiver -> speaker now
-
-    let inputNode = eng.inputNode
-    reconcileAEC(on: eng, reason: "recover-after-telephony-prestart", allowRebuild: false)
-
-    eng.reset()
-    let micMixer = AVAudioMixerNode()
-    eng.attach(micMixer)
-    eng.connect(inputNode, to: micMixer,          format: nil)
-    eng.connect(micMixer,  to: eng.mainMixerNode, format: nil)
-    micMixer.outputVolume = 0.0
-
-    if playbackNode == nil { playbackNode = AVAudioPlayerNode() }
-    if let p = playbackNode {
-        if p.engine == nil { eng.attach(p) }
-        eng.connect(p, to: eng.mainMixerNode, format: nil)
-    }
-
-    do {
-        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
-    }
-
-    // IMPORTANT: install tap and start recognition only after we *see* buffers again
-    safeRemoveTap(inputNode)
-    let tapFmt = inputNode.outputFormat(forBus: 0)
-    guard tapFmt.sampleRate > 0, tapFmt.channelCount > 0 else {
-        NSLog("[STT] recover: invalid input format post-start (sr=%.1f ch=%d)", tapFmt.sampleRate, Int(tapFmt.channelCount))
-        return
-    }
-
-    lastBufferAt = 0
-    tapFramesTotal = 0
-    inputNode.installTap(onBus: 0, bufferSize: 1024, format: tapFmt) { [weak self] buffer, _ in
-        guard let self = self else { return }
-        self.recognitionRequest?.append(buffer)
-
-        // mark that input is flowing again
-        self.tapFramesTotal &+= UInt64(buffer.frameLength)
-        self.lastBufferAt = CACurrentMediaTime()
-
-        // Kick recognition exactly once, the first time we see real audio post-call
-        if !self.startedRecognitionAfterCall && self.tapFramesTotal > 1024 {
-            DispatchQueue.main.async {
-                self.startRecognitionAfterCall()
-            }
-        }
-    }
-    // In recoverAfterTelephonyInterruption(), after engine/graph is rebuilt (near the end is fine):
-    if self.sttActive && !self.micPaused {
-        self.installPlaybackHooks()
-    }
-
-    NSLog("[STT] recovery: IO + tap ready; waiting for buffers to start recognition")
-    // do NOT set isRecoveringAfterTelephony = false here — we clear it in startRecognitionAfterCall()
-}
-
-    private func loadContextualStrings() -> [String] {
-        guard let filePath = Bundle.main.path(forResource: "words_flattened", ofType: "txt") else {
-            NSLog("words_flattened.txt not found in bundle")
-            return []
-        }
-        do {
-            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)
-            for item in rawItems {
-                var t = item.trimmingCharacters(in: .whitespacesAndNewlines)
-                t = t.replacingOccurrences(of: "\"", with: "")
-                if !t.isEmpty { cleaned.append(t) }
-            }
-            return cleaned
-        } catch {
-            NSLog("Error reading contextualStrings: \(error)")
-            return []
-        }
-    }
-
-    private func resetAudioSession() 
-    { 
-        if audioSession == nil {
-             audioSession = AVAudioSession.sharedInstance() 
-        }
-        guard let session = audioSession else { return } 
-        // Preserve & compare category exactly as original logic
-        let current = session.category
-        if priorAudioCategory == current { return }
-        audioSession = nil 
-   }
-
-   
-      private func makeFreshRequest() -> SFSpeechAudioBufferRecognitionRequest {
-        let req = SFSpeechAudioBufferRecognitionRequest()
-        if #available(iOS 16, *) { req.addsPunctuation = true }
-        req.shouldReportPartialResults = true
-        //if #available(iOS 13.0, *) { req.taskHint = .dictation }
-        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("[STT] makeFreshRequest()")
-        return req
-    }
-
-    private func startTask(_ req: SFSpeechAudioBufferRecognitionRequest) {
-        if isSpeechRecognitionLitePaused() {
-            NSLog("[STT] startTask suppressed (speechRecognitionPaused)")
-            return
-        }
-        NSLog("starting recognitionTask")
-        lastTaskStartAt = CACurrentMediaTime()
-        lastResultAt = lastTaskStartAt
-        // Bump generation and capture it for THIS task
-        activeTaskGen &+= 1
-        let myGen = activeTaskGen
-
-
-        let taskSessionId = self.sessionId
-        self.recognitionTask = self.speechRecognizer?.recognitionTask(with: req) { [weak self] result, error in
-            guard let self = self else { return }
-     
-            // ❗️Drop callbacks from older tasks
-            guard myGen == self.activeTaskGen else {
-                NSLog("[STT] stale task callback (gen \(myGen) != \(self.activeTaskGen)) → ignore")
-                return
-            }
-
-            if taskSessionId != self.sessionId { NSLog("task session mismatch -> ignore"); return }
-            self.lastResultAt = CACurrentMediaTime()
-
-            func markIfReal(_ r: SFSpeechRecognitionResult?) {
-                guard let r = r else { return }
-
-                // ✅ 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)
-
-            func rearm(_ why: String, delay: TimeInterval = 0.05) {
-                guard self.continuous else { return }
-                NSLog("REARM (\(why))")
-                self.recognitionTask?.cancel()
-                self.recognitionTask = nil
-                DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
-                    self.startTask(self.makeFreshRequest())
-                }
-            }
-
-            if let error = error {
-                NSLog("task error \(error._code): \(error.localizedDescription)")
-                // treat as transient for continuous mode
-                rearmTask(reason: "error")
-                return
-            }
-
-            guard let result = result else {
-                NSLog("task nil result")
-                rearmTask(reason: "nil-result")
-                return
-            }
-
-            let isFinal = result.isFinal
-            let parts = result.transcriptions.map { $0.segments.map { $0.substring }.joined(separator: " ") }
-            self.sendResult(error: nil,
-                            bestTranscription: result.bestTranscription.segments.map { $0.substring }.joined(separator: " "),
-                            transcriptions: parts,
-                            isFinal: isFinal)
-
-            if isFinal {
-                NSLog("task final -> onSpeechEnd")
-                self.sendEvent(name: "onSpeechEnd", body: nil)
-                if self.continuous {
-                    self.rearmTask(reason: "final")
-                } else {
-                    NSLog("non-continuous final -> teardown")
-                    self.teardown()
-                }
-            }
-        }
-    }
-
-    public func teardown() {
-        bumpGraphGen()
-        NSLog("[STT] teardown() begin")
-        isTearingDown = true
-        // ✅ HARD reset speech-lite pause state on teardown
-        resetSpeechRecognitionLitePauseState("teardown")
-        stopWatchdog()
-        consecutiveStallCount = 0
-        removeEngineObservers()
-        if let task = recognitionTask {
-            task.cancel()
-            recognitionTask = nil
-        }
-        AudioPlaybackHook.engineScheduleFile = nil
-        AudioPlaybackHook.isEngineReady = nil
-        AudioPlaybackHook.useOnlyEnginePlayback = nil
-        AudioPlaybackHook.stopEnginePlayback = nil   // ← NEW
-        sttActive = false
-
-        if let p = playbackNode {
-            p.stop()
-        }
-        playbackNode = nil
-
-        if let req = recognitionRequest {
-            req.endAudio()
-            recognitionRequest = nil
-        }
-
-        if let engine = audioEngine {
-            safeRemoveTap(engine.outputNode, bus: 0)       // <- clear IO latch if present
-            safeRemoveTap(engine.mainMixerNode, bus: 0)    // <- clear mixer probe if present
-            if engine.inputNode != nil {
-                safeRemoveTap(engine.inputNode, bus: 0)
-                engine.inputNode.reset()
-            }
-            if engine.isRunning { engine.stop() }
-            engine.reset()
-            audioEngine = nil
-            AudioPlaybackHook.currentEngine = nil   // ⬅️ add this
-        }
-        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
-
-        sessionId = nil
-        isTearingDown = false
-    }
-
-    private func isPlayerConnected(_ player: AVAudioPlayerNode?, to engine: AVAudioEngine?) -> Bool {
-        guard let p = player, let e = engine else { return false }
-        // If the node is attached and has a non-zero channel count on its output, it’s effectively connected.
-        let fmt = p.outputFormat(forBus: 0)
-        return (p.engine === e) && (fmt.channelCount > 0) && (fmt.sampleRate > 0)
-    }
-
-private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
-    if isTelephonyInterrupted || isRecoveringAfterTelephony {
-        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
-    }
-
-    if isTearingDown { return }
-
-    if !hasValidCaptureNow(allowColdEngine: true) {
-        markCaptureLost()
-        NSLog("[STT] ensureEngineRunning(\(reason)): capture not available; waiting")
-        return
-    }
-
-    let now = CFAbsoluteTimeGetCurrent()
-    if !skipCooldown, (now - lastReclaimAttempt) < reclaimCooldown {
-        NSLog("[STT] ensureEngineRunning(\(reason)) skipped (cooldown)")
-        return
-    }
-    lastReclaimAttempt = now
-
-    // (re)start engine
-    if let eng = audioEngine {
-        if !eng.isRunning {
-            do {
-                playbackNode?.stop()
-                playbackNode = nil
-                try eng.start()
-                armFirstIOCycleLatch(on: eng)
-                tryClearCaptureLossAfterStartSucceeded()
-                NSLog("🔄 AVAudioEngine restarted. running=\(eng.isRunning)")
-            } catch {
-                NSLog("❌ engine.start() failed: \(error) → rebuild")
-                rebuildEngineGraphAndRestart(reason: reason)
-                return
-            }
-        }
-    } else {
-        NSLog("[STT] ensureEngineRunning(\(reason)): no engine → rebuild")
-        rebuildEngineGraphAndRestart(reason: reason)
-        return
-    }
-
-    // ensure a task is running
-    if recognitionTask == nil {
-        if isSpeechRecognitionLitePaused() {
-            NSLog("[STT] ensureEngineRunning(\(reason)): skip startTask (speechRecognitionPaused)")
-        } else if let req = recognitionRequest {
-            startTask(req)
-        } else {
-            startTask(makeFreshRequest())
-        }
-    }
-}
-/*
-    private func ensureEngineRunning(reason: String, skipCooldown: Bool = false) {
-        if isTearingDown { return }      // ← add
-
-        // If no mic, don’t touch the graph. Wait for route/interruption end.
-
-        if !hasValidCaptureNow() {
-            markCaptureLost()
-            NSLog("[STT] ensureEngineRunning(\(reason)): capture not available; waiting")
-            return
-        }
-
-        let now = CFAbsoluteTimeGetCurrent()
-        if (now - lastReclaimAttempt) < reclaimCooldown {
-            NSLog("[STT] ensureEngineRunning(\(reason)) skipped (cooldown)")
-            return
-        }
-        lastReclaimAttempt = now
-
-        if (audioEngine != nil) && !audioEngine!.isRunning {
-            do {
-                playbackNode?.stop()
-                playbackNode = nil
-                // Possibly re-apply your format or re-install taps if the hardware changed sample rates
-                try audioEngine!.start()
-                armFirstIOCycleLatch(on: audioEngine!)
-                tryClearCaptureLossAfterStartSucceeded()
-
-                print("🔄 AVAudioEngine restarted after config change. isRunning=%@",
-                      audioEngine!.isRunning ? "YES":"NO")
-            } catch {
-                print("❌ Could not re-start after config change: \(error)")
-            }
-        }
-
-        guard let engine = audioEngine else {
-            NSLog("[STT] ensureEngineRunning(\(reason)): no engine → rebuild")
-            rebuildEngineGraphAndRestart(reason: reason)
-            return
-        }
-
-        if !engine.isRunning {
-            do {
-                try engine.start()
-                armFirstIOCycleLatch(on: engine)
-                tryClearCaptureLossAfterStartSucceeded()   // ← add this line
-
-                NSLog("[STT] ensureEngineRunning(\(reason)): engine.start() -> running=\(engine.isRunning)")
-            } catch {
-                NSLog("[STT] ensureEngineRunning(\(reason)): engine.start() failed: \(error) → rebuild")
-                rebuildEngineGraphAndRestart(reason: reason)
-                return
-            }
-        }
-
-        // If we have no active task, spin one up against the current request
-        if recognitionTask == nil {
-            if let req = recognitionRequest {
-                NSLog("[STT] ensureEngineRunning(\(reason)): no task -> startTask(existing req)")
-                startTask(req)
-            } else {
-                NSLog("[STT] ensureEngineRunning(\(reason)): no req -> makeFreshRequest + startTask")
-                startTask(makeFreshRequest())
-            }
-        }
-    }
-*/
-    /// Rebuilds AVAudioEngine graph (mic→mute mixer, player→mainMixer), reinstalls tap,
-    /// and restarts the engine. Does NOT nuke the current recognitionRequest/task unless required.
-    private func rebuildEngineGraphAndRestart(reason: String) {
-        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()
-            NSLog("[STT] rebuild: no valid input yet (skip)")
-            return
-        }
-
-        // Keep current request if present; we'll keep appending into it
-        let existingReq = self.recognitionRequest
-
-        // Tear down engine ONLY (keep session, request)
-        if let engine = audioEngine {
-            if engine.inputNode != nil {
-                safeRemoveTap(engine.inputNode, bus: 0)
-                engine.inputNode.reset()
-            }
-            if engine.isRunning { engine.stop() }
-            engine.reset()
-        }
-
-        // Recreate engine and graph
-        let newEngine = AVAudioEngine()
-        self.audioEngine = newEngine
-        AudioPlaybackHook.currentEngine = { [weak self] in self?.audioEngine }  // ⬅️ add this
-
-        installEngineObservers() // <-- IMPORTANT: observers were bound to old engine object
-        _ = setupAudioSession()                         // ✅ keep session policy consistent
-        forceSpeakerIfReceiver("rebuild:\(reason)")     // ✅ receiver -> speaker now
-
-        let inputNode = newEngine.inputNode
-        reconcileAEC(on: newEngine, reason: "rebuild-\(reason)-prestart", allowRebuild: false)
-
-        var inFmt = inputNode.outputFormat(forBus: 0)
-
-        // mic → mute mixer → mainMixer
-        let micMixer = AVAudioMixerNode()
-        newEngine.attach(micMixer)
-        newEngine.connect(inputNode, to: micMixer, format: inFmt)               // live input format
-        newEngine.connect(micMixer, to: newEngine.mainMixerNode, format: nil)   // let mixer choose
-        micMixer.outputVolume = 0.0
-
-// TTS player → (de-esser) → mainMixer
-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)
-}
-
-// // --- Aggressive low-pass only ---
-// let deEss = AVAudioUnitEQ(numberOfBands: 1)
-// let lpf = deEss.bands[0]
-// lpf.filterType = .lowPass
-// lpf.frequency  = 6500        // try 6000–7500
-// lpf.bandwidth  = 0.35        // fairly steep
-// lpf.gain       = 0.0
-// lpf.bypass     = false
-
-//     self.ttsEQ = deEss
-//     newEngine.attach(deEss)
-
-//     newEngine.disconnectNodeOutput(player)
-//     newEngine.connect(player, to: deEss, format: nil)
-//     newEngine.connect(deEss, to: newEngine.mainMixerNode, format: nil)
-// }
-
-        // Tap uses nil to follow the node’s current output format
-        newEngine.prepare()
-        do {
-            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()
-            NSLog("[STT] rebuild: engine.start() failed: \(error)")
-        }
-        
-        
-        // 2) NOW that IO is running, install the tap (format will be valid)
-        safeRemoveTap(inputNode)
-        let tapFmt = inputNode.outputFormat(forBus: 0)
-        guard tapFmt.sampleRate > 0, tapFmt.channelCount > 0 else {
-            markCaptureLost()
-            NSLog("[STT] rebuild: invalid input format after start (sr=%.1f ch=%d)",
-                tapFmt.sampleRate, Int(tapFmt.channelCount))
-            return
-        }
-
-        inputNode.installTap(onBus: 0, bufferSize: 1024, format: tapFmt) { [weak self] buffer, _ in
-            guard let self = self else { return }
-
-            // 👇 EXACT same logic as in setupAndStartRecognizing
-            self.tapFramesTotal &+= UInt64(buffer.frameLength)
-            if self.tapFramesTotal % (44100 * 2) < 1024 {
-                NSLog("[STT] tap alive, totalFrames=\(self.tapFramesTotal)")
-            }
-
-            let frames: vDSP_Length = vDSP_Length(buffer.frameLength)
-            let LEVEL_LOWPASS_TRIG: Float = 0.5
-
-            // CH0
-            if buffer.format.channelCount > 0, let ch0 = buffer.floatChannelData?[0] {
-                var peak0: Float = 0
-                vDSP_maxmgv(ch0, 1, &peak0, frames)
-                let db0: Float = (peak0 == 0) ? -100 : 20.0 * log10f(peak0)
-
-                let smoothed0 = LEVEL_LOWPASS_TRIG * db0
-                    + (1 - LEVEL_LOWPASS_TRIG) * self.averagePowerForChannel0
-                self.averagePowerForChannel0 = smoothed0
-                self.averagePowerForChannel1 = smoothed0
-            }
-
-            // CH1
-            if buffer.format.channelCount > 1, let ch1 = buffer.floatChannelData?[1] {
-                var peak1: Float = 0
-                vDSP_maxmgv(ch1, 1, &peak1, frames)
-                let db1: Float = (peak1 == 0) ? -100 : 20.0 * log10f(peak1)
-
-                let smoothed1 = LEVEL_LOWPASS_TRIG * db1
-                    + (1 - LEVEL_LOWPASS_TRIG) * self.averagePowerForChannel1
-                self.averagePowerForChannel1 = smoothed1
-            }
-
-            // Normalize 0–10 and emit
-            self.averagePowerForChannel1 = Float(
-                self._normalizedPowerLevelFromDecibels(CGFloat(self.averagePowerForChannel1)) * 10.0
-            )
-            let value = self.averagePowerForChannel1
-            self.sendEvent(name: "onSpeechVolumeChanged", body: ["value": value])
-
-            // Append to recognition
-            self.recognitionRequest?.append(buffer)
-
-            // mark that input is flowing again
-            self.lastBufferAt = CACurrentMediaTime()
-        }
-
-        // If we lost the request during rebuild, recreate + start task.
-        if self.recognitionRequest == nil {
-            if let old = existingReq {
-                self.recognitionRequest = old
-            } else {
-                self.recognitionRequest = makeFreshRequest()
-            }
-        }
-        if self.recognitionTask == nil {
-            if isSpeechRecognitionLitePaused() {
-                NSLog("[STT] rebuild: skip startTask (speechRecognitionPaused)")
-            } else {
-                startTask(self.recognitionRequest!)
-            }
-        }
-        if self.sttActive && !self.micPaused {
-            self.installPlaybackHooks()
-        }
-    }
-
-    @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
-    }
-
-       NSLog("[STT] ⚙️ AVAudioEngineConfigurationChange: ensuring engine running")
-        if (audioEngine != nil) && !audioEngine!.isRunning {
-            playbackNode?.stop()
-            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 isSpeechRecognitionLitePaused() {
-        NSLog("[STT] 📺 Media services RESET (ignored: speechRecognitionPaused)")
-        return
-    }
-     if micPaused {
-        NSLog("[STT] 📺 Media services RESET (ignored: micPaused)")
-        return
-    }
-       NSLog("[STT] 📺 Media services were RESET: reclaiming mic & session")
-        // Re-apply audio session and try to rebuild graph if needed
-        bumpGraphGen()
-        _ = setupAudioSession()
-        ensureEngineRunning(reason: "media-services-reset")
-        reconcileAEC(on: audioEngine, reason: "media-services-reset")
-        scheduleAECReconcileRetries(reason: "media-services-reset")
-    }
-
-/*?????????? Why so many changes???
-    @objc private func handleRouteChange(_ note: Notification) {
-        if isTearingDown { return }      // ← add
-
-        let info = note.userInfo ?? [:]
-        NSLog("[STT] 🔀 route change: \(info)")
-        updateSessionRouting(selectBestInput: true)   // ← add this
-
-        guard let reasonVal = info[AVAudioSessionRouteChangeReasonKey] as? UInt,
-            let reason = AVAudioSession.RouteChangeReason(rawValue: reasonVal) else {
-            ensureEngineRunning(reason: "route-change-unknown")
-            return
-        }
-        // Ignore route-change spam caused by our own adjustments
-        if isAdjustingRoute { 
-            NSLog("[STT] route change (self-induced) → ignore")
-            return
-        }
-
-        // Only rebalance on real hardware changes; avoid .categoryChange / .override
-        switch reason {
-        case .newDeviceAvailable, .oldDeviceUnavailable, .routeConfigurationChange:
-            let now = CFAbsoluteTimeGetCurrent()
-            if now - lastRouteTune > routeTuneCooldown {
-                lastRouteTune = now
-                DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-                    self?.updateSessionRouting(selectBestInput: true)
-                }
-            }
-        default:
-            break
-        }
-        ensureEngineRunning(reason: "route-change-\(reason.rawValue)")
-    }
-*/
-@objc private func handleRouteChange(_ note: Notification) {
-    if isTearingDown { return }
-    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
-    }
-
-    let info = note.userInfo ?? [:]
-    NSLog("[STT] 🔀 route change: \(info)")
-    if isTelephonyInterrupted || isRecoveringAfterTelephony {
-        NSLog("[STT] 🔀 route change (ignored during telephony/recovering): \(info)")
-        return
-    }
-
-    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)
-}
-
-    private func waitForIOCycle(_ engine: AVAudioEngine,
-                                timeout: TimeInterval = 0.7,
-                                done: @escaping (Bool) -> Void) {
-        let gen = graphGen
-        ttsSerial.async { [weak self, weak engine] in
-            guard let self = self, let eng = engine, gen == self.graphGen else { return }
-
-            if self.mixerProbeActive {
-                self.mixerProbeCompletions.append(done)
-                return
-            }
-            self.mixerProbeActive = true
-            self.mixerProbeCompletions = [done]
-
-            DispatchQueue.main.async { [weak self, weak eng] in
-                guard let self = self, let eng = eng, gen == self.graphGen else { return }
-                let mixer = eng.mainMixerNode
-                var fired = false
-                self.safeRemoveTap(mixer, bus: 0)
-
-                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
-                    self.safeRemoveTap(mixer, bus: 0)
-
-                    self.ttsSerial.async { [weak self] in
-                        guard let self = self else { return }
-                        let completions = self.mixerProbeCompletions
-                        self.mixerProbeActive = false
-                        self.mixerProbeCompletions.removeAll()
-                        DispatchQueue.main.async { if gen == self.graphGen { completions.forEach { $0(true) } } }
-                    }
-                }
-
-                DispatchQueue.main.asyncAfter(deadline: .now() + timeout) { [weak self, weak mixer] in
-                    guard let self = self, gen == self.graphGen else { return }
-                    if fired { return }
-                    self.safeRemoveTap(mixer, bus: 0)
-                    self.ttsSerial.async { [weak self] in
-                        guard let self = self else { return }
-                        let completions = self.mixerProbeCompletions
-                        self.mixerProbeActive = false
-                        self.mixerProbeCompletions.removeAll()
-                        DispatchQueue.main.async { if gen == self.graphGen { completions.forEach { $0(false) } } }
-                    }
-                }
-            }
-        }
-    }
-
-    // Call once, right after you create the engine (or inside setupAudioSession)
-    // Call once after engine is created
-    private func installEngineObservers() {
-        removeEngineObservers()
-
-        let nc = NotificationCenter.default
-
-        if let engine = audioEngine {
-            nc.addObserver(self,
-                        selector: #selector(handleEngineConfigChange(_:)),
-                        name: .AVAudioEngineConfigurationChange,
-                        object: engine)
-        }
-
-        nc.addObserver(self,
-                    selector: #selector(handleSessionInterruption(_:)),
-                    name: AVAudioSession.interruptionNotification,
-                    object: AVAudioSession.sharedInstance())
-
-        nc.addObserver(self,
-                    selector: #selector(handleRouteChange(_:)),
-                    name: AVAudioSession.routeChangeNotification,
-                    object: AVAudioSession.sharedInstance())
-
-        nc.addObserver(self,
-                    selector: #selector(handleMediaServicesReset(_:)),
-                    name: AVAudioSession.mediaServicesWereResetNotification,
-                    object: nil)
-    }
-
-    @objc private func handleSessionInterruption(_ note: Notification) {
-        guard let info = note.userInfo,
-            let typeRaw = info[AVAudioSessionInterruptionTypeKey] as? UInt,
-            let type = AVAudioSession.InterruptionType(rawValue: typeRaw) else { return }
-
-        switch type {
-        case .began:
-            resetSpeechRecognitionLitePauseState("telephony-began")
-
-            NSLog("[STT] 📞 Interruption began")
-            isTelephonyInterrupted = true
-            isRecoveringAfterTelephony = false
-            markCaptureLost()
-    
-            // Stop IO safely
-            if let eng = audioEngine {
-                safeRemoveTap(eng.inputNode); safeRemoveTap(eng.mainMixerNode); safeRemoveTap(eng.outputNode)
-                if eng.isRunning { eng.stop() }
-                eng.reset()
-            }
-
-            // Cancel the task and nil out the request — iOS STT tasks rarely recover after a hard break
-            recognitionTask?.cancel()
-            recognitionTask = nil
-            recognitionRequest = nil
-
-        case .ended:
-            isTelephonyInterrupted = false
-            NSLog("[STT] ✅ Interruption ended")
-
-            // Keep the system from thrashing us during recovery
-            isRecoveringAfterTelephony = true
-            stopWatchdog()                 // <- don't let the watchdog rearm-loop during recovery
-            startedRecognitionAfterCall = false
-            lastBufferAt = 0
-            tapFramesTotal = 0
-
-            // Re-activate the session (safe if already active)
-            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) {
-                _ = self.setupAudioSession()                 // ✅ ensures defaultToSpeaker + mode
-                self.forceSpeakerIfReceiver("telephonyEnded")// ✅ if iOS still stuck on receiver
-                self.recoverAfterTelephonyInterruption()
-            }
-
-            default: break
-        }
-    }
-
-    private func installPlaybackHooks() {
-        // Expose current engine to the hook layer (safe to overwrite each time)
-        AudioPlaybackHook.currentEngine = { [weak self] in self?.audioEngine }
-
-        // Engine readiness
-        AudioPlaybackHook.isEngineReady = { [weak self] in
-            guard let eng = self?.audioEngine else { return false }
-            return eng.isRunning
-        }
-
-        // Tell TTS layer: do NOT use AVAudioPlayer fallback while STT is active
-        AudioPlaybackHook.useOnlyEnginePlayback = { [weak self] in
-            guard let self = self else { return false }
-            return self.sttActive && !self.micPaused
-        }
-
-        // Schedule & play a file through the engine-owned AVAudioPlayerNode
-        AudioPlaybackHook.engineScheduleFile = { [weak self] url, done in
-            guard let self = self else { return false }
-
-            self.ttsSerial.async { [weak self] in
-                guard let self = self else { return }
-
-                DispatchQueue.main.async {
-                    guard !self.isTearingDown,
-                        let engine = self.audioEngine else { return }
-
-                    // If player belongs to a different engine (or got detached), recreate it
-                    if self.playbackNode?.engine !== engine || !self.isPlayerConnected(self.playbackNode, to: engine) {
-                        self.playbackNode?.stop()
-                        self.playbackNode = nil
-                    }
-
-                    // Ensure engine is running
-                    if !engine.isRunning {
-                        do {
-                            try engine.start()
-                            self.armFirstIOCycleLatch(on: engine)
-                        } catch {
-                            NSLog("[STT] TTS: engine.start() failed: \(error)")
-                            return
-                        }
-                    }
-
-                    let mixer = engine.mainMixerNode
-                    mixer.auAudioUnit.inputBusses[0].isEnabled = true
-
-                    let player = self.ensurePlaybackNode(in: engine)
-
-                    // Prime a silent buffer on a freshly attached player (stabilizes first play)
-                    if player.lastRenderTime == nil {
-                        let fmt = mixer.outputFormat(forBus: 0)
-                        if let prime = AVAudioPCMBuffer(pcmFormat: fmt, frameCapacity: 128) {
-                            prime.frameLength = 128
-                            if let ch = prime.floatChannelData {
-                                memset(ch[0], 0, Int(prime.frameLength) * MemoryLayout<Float>.size)
-                                if fmt.channelCount > 1 {
-                                    memset(ch[1], 0, Int(prime.frameLength) * MemoryLayout<Float>.size)
-                                }
-                            }
-                            player.scheduleBuffer(prime, completionHandler: nil)
-                        }
-                    }
-
-                    do {
-                        let file = try AVAudioFile(forReading: url)
-                        player.scheduleFile(file, at: nil) {
-                            DispatchQueue.main.async { done() }
-                        }
-                    } catch {
-                        NSLog("[STT] TTS schedule error: \(error)")
-                        return
-                    }
-
-                    player.volume = 0.5
-
-                    // Gate play on "engine has rendered at least one IO cycle"
-                    let startPlay = {
-                        if !player.isPlaying { player.play() }
-                    }
-
-                    if self.engineHasRenderedOnce {
-                        startPlay()
-                    } else {
-                        func tryStart(after ms: Int = 0) {
-                            DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(ms)) {
-                                if self.engineHasRenderedOnce {
-                                    startPlay()
-                                } else if ms < 1500 {
-                                    tryStart(after: ms + 100)
-                                } else {
-                                    NSLog("[STT] TTS: no IO cycle observed; skipping play to avoid crash")
-                                }
-                            }
-                        }
-                        tryStart()
-                    }
-                }
-            }
-
-            return true
-        }
-
-        // Stop only the engine playback node (keep STT engine running)
-        AudioPlaybackHook.stopEnginePlayback = { [weak self] in
-            DispatchQueue.main.async {
-                self?.playbackNode?.stop()
-            }
-        }
-    }
-
-    private func setupAndStartRecognizing(localeStr: String?) {
-        NSLog("[STT] setupAndStartRecognizing begin")
-        sttActive = true
-        // ✅ HARD reset speech-lite pause state on start/reinit
-        resetSpeechRecognitionLitePauseState("setupAndStartRecognizing")
-
-        // --- HARD RESET OF STATE (first-run safety) ---
-        isTearingDown = false
-        isTelephonyInterrupted = false
-        isRecoveringAfterTelephony = false
-
-        engineHasRenderedOnce = false
-        ioLatchActiveGen = 0
-        graphGen = 0
-
-        seenRealSpeech = false
-        engineHotAt = 0
-        lastBufferAt = 0
-        lastResultAt = 0
-        lastTaskStartAt = 0
-        consecutiveStallCount = 0
-        consecutiveNoInputResets = 0
-        lastNoInputRecoveryAt = 0
-        lastRearmAt = 0
-        lastReclaimAttempt = 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 }
-        var err: NSError?
-
-        priorAudioCategory = session.category
-
-        // Tear down resources before starting speech recognition..
-        NSLog("[STT] pre-teardown")
-        teardown()
-        // ** IMPORTANT ** Call this again as teardown marks this false
-        sttActive = true
-
-        sessionId = UUID().uuidString
-
-        let locale: Locale? = {
-            if let s = localeStr, !s.isEmpty { return Locale(identifier: s) }
-            sttActive = false
-            return nil
-        }()
-
-        if let loc = locale {
-            speechRecognizer = SFSpeechRecognizer(locale: loc)
-        } else {
-            speechRecognizer = SFSpeechRecognizer()
-        }
-        speechRecognizer?.delegate = self
-
-        // Start audio session...
-        NSLog("[STT] setupAudioSession()")
-        guard setupAudioSession() else {
-            NSLog("[STT] ERROR ERROR ******** setupAudioSession()")
-            teardown()
-            sttActive = false
-            return
-        }
-        installEngineObservers()
-
-        let request = SFSpeechAudioBufferRecognitionRequest()
-        recognitionRequest = request
-
-        if #available(iOS 16, *) {
-            request.addsPunctuation = true
-        } else {
-            // Fallback on earlier versions
-        }
-        request.shouldReportPartialResults = true
-        //if #available(iOS 13.0, *) { request.taskHint = .dictation }
-        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)
-            teardown()
-            return
-        }
-
-        if audioEngine == nil {
-            bumpGraphGen(); 
-            audioEngine = AVAudioEngine()
-        }
-        AudioPlaybackHook.currentEngine = { [weak self] in self?.audioEngine }  // ⬅️ add this
-
-        do {
-            guard let engine = audioEngine else { throw NSError(domain: "voice.audio", code: -1) }
-            let inputNode = engine.inputNode
-            let _ = inputNode // presence check
-
-            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 { ... }
-
-            NSLog("[STT] AEC enable done")
-
-            // --- FIXED WIRING: use live format on first hop, nil downstream, nil for tap ---
-            let inFmt = engine.inputNode.outputFormat(forBus: 0)
-
-            // 1) Mute only the mic path, not the whole main mixer
-            let micMixer = AVAudioMixerNode()
-            engine.attach(micMixer)
-            // Use the live input format for input → micMixer
-            engine.connect(inputNode, to: micMixer, format: inFmt)
-            // Let main mixer pick downstream format
-            engine.connect(micMixer, to: engine.mainMixerNode, format: nil)
-            micMixer.outputVolume = 0.0  // ← you won't hear your own mic
-
-            // 2) Prepare a player node for TTS inside the SAME engine/graph
-            let player = AVAudioPlayerNode()
-            self.playbackNode = player
-            engine.attach(player)
-
-// // --- Aggressive low-pass only ---
-// let deEss = AVAudioUnitEQ(numberOfBands: 1)
-// let lpf = deEss.bands[0]
-// lpf.filterType = .lowPass
-// lpf.frequency  = 6500        // try 6000–7500
-// lpf.bandwidth  = 0.35        // fairly steep
-// lpf.gain       = 0.0
-// lpf.bypass     = false
-
-// self.ttsEQ = deEss
-// engine.attach(deEss)
-
-// engine.disconnectNodeOutput(player)
-// engine.connect(player, to: deEss, format: nil)
-// engine.connect(deEss, to: engine.mainMixerNode, format: nil)
-            engine.connect(player, to: engine.mainMixerNode, format: nil)
-
-
-            NSLog("[STT] graph connected (mic->mute mixer, player->mainMixer)")
-
-            var tapFrames: UInt64 = 0
-            // Tap uses nil so it follows the node’s current output format (survives route SR changes)
-
-            safeRemoveTap(inputNode, bus: 0)
-            let format = inputNode.outputFormat(forBus: 0) // <- prefer explicit format
-            guard format.sampleRate > 0, format.channelCount > 0 else {
-                NSLog("[STT] skip tap: invalid input format (sr=\(format.sampleRate), ch=\(format.channelCount))")
-                return
-            }
-
-            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
-                self.tapFramesTotal &+= UInt64(buffer.frameLength)
-
-                if self.tapFramesTotal % (44100 * 2) < 1024 {  // ~every 2s at 44.1k
-                    NSLog("[STT] tap alive, totalFrames=\(self.tapFramesTotal)")
-                }
-
-                let frames: vDSP_Length = vDSP_Length(buffer.frameLength)
-                let LEVEL_LOWPASS_TRIG: Float = 0.5
-
-                // CH0
-                if buffer.format.channelCount > 0, let ch0 = buffer.floatChannelData?[0] {
-                    var peak0: Float = 0
-                    vDSP_maxmgv(ch0, 1, &peak0, frames)
-                    let db0: Float = (peak0 == 0) ? -100 : 20.0 * log10f(peak0)
-
-                    let smoothed0 = LEVEL_LOWPASS_TRIG * db0
-                                + (1 - LEVEL_LOWPASS_TRIG) * self.averagePowerForChannel0
-                    self.averagePowerForChannel0 = smoothed0
-                    self.averagePowerForChannel1 = smoothed0
-                }
-
-                // CH1
-                if buffer.format.channelCount > 1, let ch1 = buffer.floatChannelData?[1] {
-                    var peak1: Float = 0
-                    vDSP_maxmgv(ch1, 1, &peak1, frames)
-                    let db1: Float = (peak1 == 0) ? -100 : 20.0 * log10f(peak1)
-
-                    let smoothed1 = LEVEL_LOWPASS_TRIG * db1
-                                + (1 - LEVEL_LOWPASS_TRIG) * self.averagePowerForChannel1
-                    self.averagePowerForChannel1 = smoothed1
-                }
-
-                // Normalize 0–10 and emit
-                self.averagePowerForChannel1 = Float(self._normalizedPowerLevelFromDecibels(CGFloat(self.averagePowerForChannel1)) * 10.0)
-                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
-                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()
-            }
-
-            engine.prepare()
-            NSLog("[STT] audioEngine prepare")
-            var audioSessionError: NSError?
-            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
-            }
-
-            // after engine.start() success:
-            engineHotAt = CACurrentMediaTime()
-            seenRealSpeech = false
-            NSLog("engine HOT at \(engineHotAt)")
-            sendEvent(name: "onSpeechStart", body: nil) // engine hot signal (keep if you want)
-            startTask(makeFreshRequest())
-            
-            installPlaybackHooks()
-
-            startWatchdog()
-
-            NSLog("audioEngine startAndReturnError")
-            if let audioSessionError = audioSessionError {
-                NotificationCenter.default.addObserver(self,
-                                                       selector: #selector(self.handleEngineConfigChange(_:)),
-                                                       name: .AVAudioEngineConfigurationChange,
-                                                       object: engine)
-                NSLog("audioEngine audioSessionError!=nil")
-                self.sendResult(error: ["code": "audio", "message": audioSessionError.localizedDescription],
-                                bestTranscription: nil, transcriptions: nil, isFinal: nil)
-                NSLog("[STT] self sendResult")
-                // self.teardown()
-                NSLog("[STT] Removed self teardown")
-                return
-            }
-            NSLog("After Start recording and append recording")
-            DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) { [weak self] in
-                guard let self = self else { return }
-                let running = self.audioEngine?.isRunning ?? false
-                let taskState = self.recognitionTask?.state.rawValue ?? -1
-                NSLog("[STT] health: engineRunning=\(running) taskState=\(taskState)")
-            }
-
-            NSLog("After if audioSessionError != nil")
-        } catch let e as NSError {
-            sendResult(error: ["code": "start_recording", "message": e.localizedDescription],
-                       bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            NSLog("End of init...")
-            return
-        }
-    }
-
-    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 }
-        let minDb: Float = -80.0
-        let pow10_min = powf(10.0, 0.05 * minDb)
-        let pow10_db  = powf(10.0, 0.05 * Float(decibels))
-        let power = powf((pow10_db - pow10_min) * (1.0 / (1.0 - pow10_min)), 1.0 / 2.0)
-        if power < 1.0 { return CGFloat(power) } else { return 1.0 }
-    }
-
-    private func sendEvent(name: String, body: [String: Any]?) {
-        delegate?.stt(self, didEmitEvent: name, body: body)
-    }
-
-    /// Exact event behavior preserved from ObjC `sendResult`.
-    private func sendResult(error: [String: Any]?,
-                            bestTranscription: String?,
-                            transcriptions: [String]?,
-                            isFinal: Bool?) {
-        NSLog("[STT] sendResult called")
-        if (self.micPaused || self.speechRecognitionPaused) {
-            if self.micPaused && self.speechRecognitionPaused {
-                NSLog("[STT] sendResult suppressed: micPaused + speechRecognitionPaused")
-            } else if self.micPaused {
-                NSLog("[STT] sendResult suppressed: micPaused")
-            } else {
-                NSLog("[STT] sendResult suppressed: speechRecognitionPaused")
-            }
-            return
-        }
-
-        if let error = error {
-            sendEvent(name: "onSpeechError", body: ["error": error])
-        }
-        if let best = bestTranscription {
-            sendEvent(name: "onSpeechResults", body: ["value": [best]])
-        }
-        if let trans = transcriptions {
-            sendEvent(name: "onSpeechPartialResults", body: ["value": trans])
-        }
-        if let isFinal = isFinal {
-            sendEvent(name: "onSpeechRecognized", body: ["isFinal": isFinal])
-        }
-    }
-
-    // MARK: - SFSpeechRecognizerDelegate
-
-    public func speechRecognizer(_ speechRecognizer: SFSpeechRecognizer, availabilityDidChange available: Bool) {
-        if available == false {
-            sendResult(error: ["message": "Speech recognition is not available now"],
-                       bestTranscription: nil, transcriptions: nil, isFinal: nil)
-        }
-    }
-
-    // MARK: - Small helper to recreate recognizer (used by watchdog)
-    private func recreateSpeechRecognizerPreservingLocale() {
-        let loc = speechRecognizer?.locale
-        speechRecognizer = loc != nil ? SFSpeechRecognizer(locale: loc!) : SFSpeechRecognizer()
-        speechRecognizer?.delegate = self
-        NSLog("[STT] recreated SFSpeechRecognizer (locale preserved: \(loc?.identifier ?? "default"))")
-    }
-}