react-native-davoice-tts 1.0.209 → 1.0.211

package/ios/TTSRNBridge/DavoiceTTS.xcframework/ios-arm64_x86_64-simulator/DavoiceTTS.framework/DaVoiceSTT.swift__

@@ -0,0 +1,1329 @@
+// 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
+
+    // MARK: - Private
+    private var speechRecognizer: SFSpeechRecognizer?
+    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
+    private var audioEngine: AVAudioEngine?
+    private var recognitionTask: SFSpeechRecognitionTask?
+    private var audioSession: AVAudioSession?
+    private var isTearingDown: Bool = false
+    private var sessionId: String?
+    private var priorAudioCategory: AVAudioSession.Category?
+    private var averagePowerForChannel0: Float = 0
+    private var averagePowerForChannel1: Float = 0
+
+    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
+
+    // --- 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 booting = false
+    private var reqConsumed = false   // tracks if a request has been used to start a task
+
+    // --- Recovery & diagnostics ---
+    private var recoverySeq = 0
+    private var lastRecoveryAt: CFTimeInterval = 0
+    private var lastTaskOrigin: String = "cold"
+    // --- Mic pause state ---
+    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
+
+    // partial cadence monitor
+    private var emaPartialGap: Double = 0   // exponential moving average of time between partials
+    private let emaAlpha: Double = 0.3
+    // Add near your other state:
+    private var ioLatchActiveGen: UInt64 = 0
+
+    // 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
+    // Add near your other state:
+    private var lastLocaleStr: String?
+    private var restartInFlight = false
+
+    private func restartSpeechCold(_ reason: String) {
+        guard !restartInFlight else { return }
+        restartInFlight = true
+        NSLog("[STT] 🔁 cold-restart (\(reason))")
+
+        // Full teardown, brief breather, then fresh start with same locale
+        teardown()
+        let locale = lastLocaleStr
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) { [weak self] in
+            guard let self = self else { return }
+            self.restartInFlight = false
+            self.setupAndStartRecognizing(localeStr: locale)
+        }
+    }
+
+    // MARK: - Event names (unchanged)
+    public static let supportedEvents: [String] = [
+        "onSpeechResults",
+        "onSpeechStart",
+        "onSpeechPartialResults",
+        "onSpeechError",
+        "onSpeechEnd",
+        "onSpeechRecognized",
+        "onSpeechVolumeChanged"
+    ]
+
+    private var graphGen: UInt64 = 0
+    @inline(__always) private func bumpGraphGen() { graphGen &+= 1; ioLatchActiveGen = 0 }
+
+    @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 we have a node but it's tied to a different engine or got disconnected, recreate it.
+        if let p = playbackNode, p.engine === engine {
+            return p
+        }
+        let p = AVAudioPlayerNode()
+        playbackNode = p
+        engine.attach(p)
+        // Connect with nil format so the mixer does SRC if needed
+        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
+    }
+
+        // MARK: - Public pause/unpause API
+    @objc public func pauseMicrophone() {
+        DispatchQueue.main.async {
+
+            self.teardown()           // full cleanup of recognizer + engine
+
+            NSLog("[STT] 🔇 Microphone paused (clean teardown; TTS in playback mode)")
+        }
+    }
+
+    @objc public func unPauseMicrophone() {
+        DispatchQueue.main.async {
+            self.booting = true
+            // Cold start through your existing, stable path
+            self.startSpeech(localeStr: self.lastLocaleStr)
+            self.booting = false
+
+            NSLog("[STT] 🎙️ Microphone unpaused (clean restart via startSpeech)")
+        }
+    }
+
+    private func rearmTask(reason: String) {
+        if self.booting { return }               // ← add
+        // Cancel old task only — keep the engine and tap running.
+        recognitionTask?.cancel()
+        recognitionTask = nil
+
+        seenRealSpeech = false
+        lastTaskStartAt = CACurrentMediaTime()
+        startTask(makeFreshRequest())
+        NSLog("[STT] rearmTask(\(reason)) -> new task started")
+    }
+
+    private func checkTaskHealth() {
+        if self.booting { return }               // ← add
+        guard let engine = audioEngine else { return }
+        let now = CACurrentMediaTime()
+
+        // Engine down? Let your existing logic handle it; just bail.
+        if !engine.isRunning { return }
+
+        // If recognizer is globally unavailable, don’t thrash — wait until it flips back.
+        if let rec = speechRecognizer, rec.isAvailable == false {
+            NSLog("[STT] watchdog: recognizer unavailable; waiting…")
+            return
+        }
+
+        // No task at all? Spin one up.
+        if recognitionTask == nil {
+            if now - lastRearmAt > rearmCooldownTask {
+                NSLog("[STT] watchdog: no task -> start fresh request")
+                lastRearmAt = now
+                startTask(makeFreshRequest())
+            }
+            return
+        }
+
+        // If we’ve had buffers recently but no results for a while, assume the task is stuck.
+        let noResultsFor = now - lastResultAt
+        let hadRecentAudio = (now - lastBufferAt) < max(2.0, stallThreshold) // tap is alive
+
+        if hadRecentAudio && noResultsFor > stallThreshold {
+            if now - lastRearmAt > rearmCooldownTask {
+                consecutiveStallCount += 1
+                NSLog("[STT] watchdog: stall detected (no results for \(Int(noResultsFor))s, audio flowing). rearm #\(consecutiveStallCount)")
+
+                rearmTask(reason: "watchdog-stall")
+                lastRearmAt = now
+
+                // If we stall repeatedly, recreate the recognizer itself (server/session could be hosed)
+                if consecutiveStallCount >= 3 {
+                    recreateSpeechRecognizerPreservingLocale()
+                    consecutiveStallCount = 0
+                }
+            }
+        } else if hadRecentAudio {
+            // Healthy path: audio & results are flowing; reset stall counter
+            consecutiveStallCount = 0
+        }
+    }
+
+    public func startSpeech(localeStr: String?) {
+        NSLog("[STT] startSpeech(locale=\(localeStr ?? "nil"))")
+        lastLocaleStr = localeStr
+
+        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???")
+        
+        let s = AVAudioSession.sharedInstance()
+
+        // fast checks & logs can run on main
+        let inputs = s.currentRoute.inputs
+        guard !inputs.isEmpty else {
+            NSLog("[STT] ⚠️ No capture route (likely A2DP). Deferring engine start.")
+            return
+        }
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            do { try s.setActive(false, options: [.notifyOthersOnDeactivation]) }
+            catch { NSLog("[STT] setActive false failed: \(error.localizedDescription)") }
+
+            let hasWiredOrCar = s.currentRoute.outputs.contains {
+                $0.portType == .headphones || $0.portType == .carAudio || $0.portType == .usbAudio
+            }
+            if selectBestInput, let all = s.availableInputs {
+                let bt    = all.first { $0.portType == .bluetoothHFP || $0.portType == .bluetoothLE }
+                let wired = all.first { $0.portType == .headsetMic }
+                let built = all.first { $0.portType == .builtInMic }
+                let best  = bt ?? wired ?? built
+                do {
+                    if s.preferredInput?.uid != best?.uid { try s.setPreferredInput(best) }
+                    if let builtIn = best, builtIn.portType == .builtInMic,
+                    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 != .voiceChat || s.categoryOptions != opts {
+                do { try s.setCategory(.playAndRecord, mode: .voiceChat, options: opts) }
+                catch { NSLog("[STT] setCategory failed: \(error.localizedDescription)") }
+            }
+
+            do { try s.setActive(true, options: []) }
+            catch { NSLog("[STT] setActive failed: \(error.localizedDescription)") }
+
+            // Optional: force 16k after activation
+            self.force16kIfPossible(s)
+
+            // 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) {
+        let hasExternalOutput = session.currentRoute.outputs.contains {
+            switch $0.portType {
+            case .headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .airPlay, .carAudio, .usbAudio:
+                return true
+            default: return false
+            }
+        }
+        if hasExternalOutput { return }
+
+        try? session.setPreferredSampleRate(16_000)
+        if session.isInputAvailable { try? session.setPreferredInputNumberOfChannels(1) }
+        try? session.setPreferredOutputNumberOfChannels(1)
+        try? session.setPreferredIOBufferDuration(0.02) // ~20 ms frames
+    }
+
+    // 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)") }
+
+        // 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: .voiceChat, options: opts)
+        } catch { err = error as NSError }
+
+        // Force 16k before and after activation (some routes settle only after setActive)
+        force16kIfPossible(session)
+        do { try session.setActive(true) } catch { err = error as NSError }
+        NSLog("[STT] session SR=%.1f inCh=%d outCh=%d (wanted 16000)",
+              session.sampleRate,
+              Int(session.inputNumberOfChannels),
+              Int(session.outputNumberOfChannels))
+        force16kIfPossible(session)
+
+        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 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 isHeadSetBluetooth() -> Bool {
+        for port in AVAudioSession.sharedInstance().availableInputs ?? [] {
+            if port.portType == .bluetoothHFP { return true }
+        }
+        return false
+    }
+
+    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 {
+            let contents = try String(contentsOfFile: filePath, encoding: .utf8)
+            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 }
+        req.contextualStrings = loadContextualStrings()
+        self.recognitionRequest = req
+        self.reqConsumed = false     // <— reset here
+        NSLog("makeFreshRequest()")
+        return req
+    }
+
+    private func startTask(_ req: SFSpeechAudioBufferRecognitionRequest) {
+        NSLog("starting recognitionTask")
+        lastTaskStartAt = CACurrentMediaTime()
+        lastResultAt = lastTaskStartAt
+        let taskSessionId = self.sessionId
+
+        self.recognitionTask = self.speechRecognizer?.recognitionTask(with: req) { [weak self] result, error in
+            guard let self = self else { return }
+            if taskSessionId != self.sessionId { NSLog("task session mismatch -> ignore"); return }
+            self.lastResultAt = CACurrentMediaTime()
+
+            // ----- ERROR HANDLING (single block) -----
+            if let error = error {
+                let nserr = error as NSError
+                NSLog("task error \(nserr.code): \(nserr.localizedDescription)")
+
+                // Cold restart for local speech/XPC faults
+                if (nserr.domain == "kAFAssistantErrorDomain" && (nserr.code == 1107 || nserr.code == 1101)) ||
+                (nserr.domain == NSCocoaErrorDomain && nserr.code == 4097) {
+                    self.restartSpeechCold("localspeech-\(nserr.code)")
+                    return
+                }
+
+                // Otherwise: transient stall → rearm the task
+                self.rearmTask(reason: "error")
+                return
+            }
+
+            // ----- RESULT HANDLING -----
+            guard let result = result else {
+                NSLog("task nil result")
+                self.rearmTask(reason: "nil-result")
+                return
+            }
+
+            // Mark first real speech once
+            let best = result.bestTranscription.formattedString.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !best.isEmpty || result.transcriptions.contains(where: { !$0.formattedString.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) {
+                if !self.seenRealSpeech {
+                    self.seenRealSpeech = true
+                    NSLog("first real speech detected -> onSpeechStart to JS")
+                    self.sendEvent(name: "onSpeechStart", body: nil)
+                }
+            }
+
+            // Emit partials/finals
+            let parts = result.transcriptions.map { $0.formattedString }
+            self.sendResult(error: nil,
+                            bestTranscription: result.bestTranscription.formattedString,
+                            transcriptions: parts,
+                            isFinal: result.isFinal)
+
+            if result.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
+        stopWatchdog()
+        consecutiveStallCount = 0
+
+        // 1) Tell the request we're done so LocalSpeech sees EOF
+        if let req = recognitionRequest {
+            req.endAudio()
+        }
+        // 2) Cancel the task (don’t nil the request yet, let it flush)
+        recognitionTask?.cancel()
+        recognitionTask = nil
+
+        // 3) Small grace period before ripping the engine/session
+        let grace = DispatchTime.now() + .milliseconds(300)
+        DispatchQueue.main.asyncAfter(deadline: grace) { [weak self] in
+            guard let self = self else { return }
+            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 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
+            }
+            mixerProbeActive = false
+            mixerProbeCompletions.removeAll()
+
+            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 waitForStableInputThen(_ block: @escaping () -> Void) {
+        let s = AVAudioSession.sharedInstance()
+        if !s.currentRoute.inputs.isEmpty {
+            block(); return
+        }
+        // try again shortly; this resolves within a few ticks after unpause
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) { [weak self] in
+            guard self != nil else { return }
+            self?.waitForStableInputThen(block)
+        }
+    }
+
+    /// Try to keep the capture alive without tearing down recognition.
+    /// 1) If engine exists but not running → try start()
+    /// 2) If start fails or graph became invalid → rebuild graph and start
+    /// 3) If we don’t have a task yet, start one.
+    private func ensureEngineRunning(reason: String) {
+        if booting { return }   // <— ignore while booting/pause
+
+        let now = CFAbsoluteTimeGetCurrent()
+        let skipCooldown = reason.hasPrefix("route-change") // ← bypass for route changes
+        if !skipCooldown && (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!)
+
+                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)
+                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)")
+                reqConsumed = true
+                startTask(req)
+            } else {
+                NSLog("[STT] ensureEngineRunning(\(reason)): no req -> makeFreshRequest + startTask")
+                let newReq = makeFreshRequest()
+                reqConsumed = true
+                startTask(newReq)
+            }
+        }
+    }
+
+    /// 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))")
+
+        // 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
+
+        let inputNode = newEngine.inputNode
+
+        let s = AVAudioSession.sharedInstance()
+        let speakerRoute = s.currentRoute.outputs.contains { $0.portType == .builtInSpeaker }
+        let usingBuiltInMic = (s.preferredInput?.portType == .builtInMic) ||
+                      (s.currentRoute.inputs.first?.portType == .builtInMic)
+
+        if speakerRoute && usingBuiltInMic {
+            do {
+                try inputNode.setVoiceProcessingEnabled(true)
+            } catch {
+                NSLog("[STT] rebuild: failed to enable voice processing: \(error)")
+            }
+        }
+        if #available(iOS 17.0, *) {
+            var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
+            duck.enableAdvancedDucking = false
+            duck.duckingLevel = .min
+            inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
+        }
+
+        // --- FIXED WIRING: use live format on first hop, nil downstream, nil for tap ---
+        let inFmt = newEngine.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
+
+        playbackNode?.stop()
+
+        // TTS player → mainMixer (keep same player if possible, else recreate)
+        let player = AVAudioPlayerNode()
+        playbackNode = player
+        newEngine.attach(player)
+        newEngine.connect(player, to: newEngine.mainMixerNode, format: nil)
+
+        safeRemoveTap(inputNode, bus: 0)
+        let format = inputNode.outputFormat(forBus: 0) // <- prefer explicit format
+
+        // Tap uses nil to follow the node’s current output format
+        inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { [weak self] buffer, _ in
+            guard let self = self else { return }
+
+            // (same level metering as your current code)
+            let frames: vDSP_Length = vDSP_Length(buffer.frameLength)
+            let LP: Float = 0.5
+
+            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 sm0 = LP * db0 + (1 - LP) * self.averagePowerForChannel0
+                self.averagePowerForChannel0 = sm0
+                self.averagePowerForChannel1 = sm0
+            }
+            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 sm1 = LP * db1 + (1 - LP) * self.averagePowerForChannel1
+                self.averagePowerForChannel1 = sm1
+            }
+            self.averagePowerForChannel1 = Float(self._normalizedPowerLevelFromDecibels(CGFloat(self.averagePowerForChannel1)) * 10.0)
+            self.sendEvent(name: "onSpeechVolumeChanged", body: ["value": self.averagePowerForChannel1])
+
+            self.recognitionRequest?.append(buffer)
+            self.lastBufferAt = CACurrentMediaTime()
+        }
+
+        newEngine.prepare()
+        do {
+            try newEngine.start()
+            armFirstIOCycleLatch(on: newEngine)
+            NSLog("[STT] rebuild: engine.start() ok, running=\(newEngine.isRunning)")
+        } catch {
+            NSLog("[STT] rebuild: engine.start() failed: \(error)")
+        }
+
+        if self.recognitionRequest == nil {
+            self.recognitionRequest = makeFreshRequest()
+        }
+        if self.recognitionTask == nil, let req = self.recognitionRequest {
+            startTask(req)
+        }
+    }
+
+    @objc private func handleEngineConfigChange(_ note: Notification) {
+        if self.booting { return }               // ← add
+        NSLog("[STT] ⚙️ AVAudioEngineConfigurationChange: ensuring engine running")
+        if (audioEngine != nil) && !audioEngine!.isRunning {
+            playbackNode?.stop()
+            playbackNode = nil
+        }
+        ensureEngineRunning(reason: "engine-config-change")
+    }
+
+    @objc private func handleMediaServicesReset(_ note: Notification) {
+        if self.booting { return }               // ← add
+        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")
+    }
+
+    @objc private func handleRouteChange(_ note: Notification) {
+        if booting { return }               // ← add
+        let info = note.userInfo ?? [:]
+        NSLog("[STT] 🔀 route change: \(info)")
+
+        guard let reasonVal = info[AVAudioSessionRouteChangeReasonKey] as? UInt,
+            let reason = AVAudioSession.RouteChangeReason(rawValue: reasonVal) else {
+            ensureEngineRunning(reason: "route-change-unknown")
+            return
+        }
+
+        // On any meaningful route change, reclaim mic
+        switch reason {
+        case .oldDeviceUnavailable, .newDeviceAvailable, .categoryChange, .routeConfigurationChange, .override:
+            ensureEngineRunning(reason: "route-change-\(reason.rawValue)")
+        default:
+            break
+        }
+    }
+
+    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() {
+        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) {
+        if booting { return }               // ← add
+        guard
+            let info = note.userInfo,
+            let typeVal = info[AVAudioSessionInterruptionTypeKey] as? UInt,
+            let type = AVAudioSession.InterruptionType(rawValue: typeVal)
+        else { return }
+
+        if type == .ended {
+            // On real “render err” Core Audio posts an interruption END
+            NSLog("Session interruption ended (possible render err):")
+        }
+    }
+
+    // Add to STT
+    private func safeMixerFormat(_ engine: AVAudioEngine) -> AVAudioFormat {
+        // Try the mainMixer's current format first
+        var fmt = engine.mainMixerNode.outputFormat(forBus: 0)
+        if fmt.sampleRate > 0 && fmt.channelCount > 0 { return fmt }
+
+        // Fallbacks if it’s still 0 Hz (race during route changes)
+        let sessionSR = AVAudioSession.sharedInstance().sampleRate
+        let ioFmt = engine.outputNode.inputFormat(forBus: 0) // IO unit’s input
+        let sr = (fmt.sampleRate > 0 ? fmt.sampleRate
+            : (ioFmt.sampleRate > 0 ? ioFmt.sampleRate
+            :  (sessionSR > 0 ? sessionSR : 48000)))
+        let ch = max(1, Int((fmt.channelCount > 0 ? fmt.channelCount : ioFmt.channelCount)))
+        return AVAudioFormat(standardFormatWithSampleRate: sr, channels: AVAudioChannelCount(ch))!
+    }
+
+    private func setupAndStartRecognizing(localeStr: String?) {
+        if booting { return }
+            booting = true
+        NSLog("[STT] setupAndStartRecognizing begin")
+        sttActive = true
+
+        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 = makeFreshRequest()               
+        recognitionRequest = request
+
+        guard recognitionRequest != nil else {
+            sendResult(error: ["code": "recognition_init"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
+            teardown()
+            return
+        }
+
+        if audioEngine == nil {
+            bumpGraphGen(); 
+            audioEngine = AVAudioEngine()
+        }
+        do {
+            guard let engine = audioEngine else { throw NSError(domain: "voice.audio", code: -1) }
+            let inputNode = engine.inputNode
+            let _ = inputNode // presence check
+
+            let s = AVAudioSession.sharedInstance()
+            let speakerRoute = s.currentRoute.outputs.contains { $0.portType == .builtInSpeaker }
+            let usingBuiltInMic = (s.preferredInput?.portType == .builtInMic) ||
+                        (s.currentRoute.inputs.first?.portType == .builtInMic)
+
+            if speakerRoute && usingBuiltInMic {
+                // Enable voice processing (AEC)
+                do {
+                    try inputNode.setVoiceProcessingEnabled(true)
+                } catch {
+                    NSLog("Failed to enable voice processing for AEC on input node: \(error)")
+                }
+            }
+
+            if #available(iOS 17.0, *) {
+                var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
+                duck.enableAdvancedDucking = false   // disable advanced (VAD-based) ducking
+                duck.duckingLevel = .min             // “as loud as possible” for other audio
+                inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
+            }
+
+            // 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)
+            // Let the mixer choose the format for TTS
+            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
+
+            inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { [weak self] buffer, _ in
+                // Strongify self once
+                guard let self = self else { return }
+                tapFrames &+= UInt64(buffer.frameLength)
+                if tapFrames % (44100 * 2) < 1024 {  // ~every ~2s at 44.1k
+                    NSLog("[STT] tap alive, totalFrames=\(tapFrames)")
+                }
+
+                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)
+
+                // inside inputNode.installTap { buffer, _ in
+                self.lastBufferAt = CACurrentMediaTime()
+            }
+
+            engine.prepare()
+            NSLog("[STT] audioEngine prepare")
+            var audioSessionError: NSError?
+            do {
+                try engine.start()
+                armFirstIOCycleLatch(on: engine)
+            } 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)
+            self.reqConsumed = true
+            startTask(recognitionRequest!)
+            self.booting = false
+
+            // Engine is up; expose 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
+                return self?.sttActive == true
+            }
+
+            startWatchdog()
+
+            AudioPlaybackHook.engineScheduleFile = { [weak self] url, done in
+                self?.ttsSerial.async { [weak self] in
+                    DispatchQueue.main.async {
+                        guard let self = self, !self.isTearingDown, let engine = self.audioEngine else { return }
+                        // Always recreate the player if lastRenderTime might be stale
+                        if self.playbackNode?.engine !== engine || !self.isPlayerConnected(self.playbackNode, to: engine) {
+                            self.playbackNode?.stop()
+                            self.playbackNode = nil
+                        }
+                        // Ensure 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)
+
+                        // Always prime a silent buffer on a freshly attached player
+                        if player.lastRenderTime == nil {
+                            let fmt = self.safeMixerFormat(engine)
+                            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
+                        }
+
+                        // Gate first-ever play on the engineHasRenderedOnce latch
+                        let startPlay = {
+                            if !player.isPlaying { player.play() }
+                        }
+                        if self.engineHasRenderedOnce {
+                            startPlay()
+                        } else {
+                            // Poll briefly until first IO cycle observed
+                            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) } // up to ~1.5s on BT
+                                    else { NSLog("[STT] TTS: no IO cycle observed; skipping play to avoid crash") }
+                                }
+                            }
+                            tryStart()
+                        }
+                    }
+                }
+                return true
+            }
+
+            AudioPlaybackHook.stopEnginePlayback = { [weak self] in
+                DispatchQueue.main.async {
+                    guard let self = self else { return }
+                    // Stop only the TTS playback node; keep the engine running for STT
+                    self.playbackNode?.stop()
+                }
+            }
+
+            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
+        }
+    }
+
+    // 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?) {
+        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"))")
+    }
+}