react-native-davoice-tts 1.0.217 → 1.0.219

package/ios/TTSRNBridge/DavoiceTTS.xcframework/ios-arm64/DavoiceTTS.framework/DaVoiceSTT.swift.latest

@@ -1,1359 +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
-
-    // 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 observedEngineForConfigChange: AVAudioEngine?
-    // Pending TTS while engine warms/recovers
-    private var pendingTTSSchedules: [(url: URL, done: () -> Void)] = []
-    private let ttsSerial = DispatchQueue(label: "stt.tts.serial")
-
-    // --- Recovery & diagnostics ---
-    private var recoverySeq = 0
-    private var lastRecoveryAt: CFTimeInterval = 0
-    private var lastTaskOrigin: String = "cold"
-    private enum GraphState { case cold, starting, hot, unstable }
-    private var graphState: GraphState = .cold
-    private var stabilityTimer: Timer?
-
-    private func setGraphState(_ s: GraphState, why: String) {
-        graphState = s
-        NSLog("[STT] graphState -> \(s) (\(why))")
-    }
-
-    private func markUnstableThenRecheck(after seconds: TimeInterval = 0.35, why: String) {
-        setGraphState(.unstable, why: why)
-        stabilityTimer?.invalidate()
-        stabilityTimer = Timer.scheduledTimer(withTimeInterval: seconds, repeats: false) { [weak self] _ in
-            guard let self = self, let eng = self.audioEngine else { return }
-            if eng.isRunning {
-                self.setGraphState(.hot, why: "debounce elapsed & engine running")
-                self.tryFlushPendingTTS()   // ← ADD THIS LINE
-            } else {
-                do {
-                    try eng.start()
-                    self.setGraphState(.hot, why: "restarted after debounce")
-                    self.tryFlushPendingTTS()   // ← ADD THIS LINE
-                } catch {
-                    self.setGraphState(.starting, why: "start failed: \(error.localizedDescription)")
-                }
-            }
-        }
-        RunLoop.main.add(stabilityTimer!, forMode: .common)
-    }
-
-    private func tryFlushPendingTTS() {
-        ttsSerial.async { [weak self] in
-            guard let self = self, let engine = self.audioEngine else { return }
-            // Check readiness: engine running + mixer has valid format
-            let mixFmt = engine.mainMixerNode.outputFormat(forBus: 0)
-            guard engine.isRunning, mixFmt.sampleRate > 0, mixFmt.channelCount > 0 else { return }
-
-            // Drain queue in-order
-            while !self.pendingTTSSchedules.isEmpty {
-                let item = self.pendingTTSSchedules.removeFirst()
-                DispatchQueue.main.async { [weak self] in
-                    guard let self = self else { return }
-                    // Ensure player is attached & connected
-                    if self.playbackNode?.engine !== engine || !self.isPlayerConnected(self.playbackNode, to: engine) {
-                        self.playbackNode?.stop()
-                        self.playbackNode = nil
-                    }
-                    let player = self.ensurePlaybackNode(in: engine)
-
-                    // Prime → play → schedule
-                    self.primePlayer(player, engine: engine)
-                    if !player.isPlaying { player.play() }
-
-                    do {
-                        let file = try AVAudioFile(forReading: item.url)
-                        player.scheduleFile(file, at: nil) {
-                            DispatchQueue.main.async { item.done() }
-                        }
-                        NSLog("[STT] TTS: scheduled pending via AVAudioEngine: \(item.url.lastPathComponent)")
-                    } catch {
-                        NSLog("[STT] TTS pending schedule error: \(error)")
-                        // We still *don’t* fallback by design.
-                    }
-                }
-            }
-        }
-    }
-
-    private func engineReadyForPlayback(_ engine: AVAudioEngine?) -> Bool {
-        guard let e = engine, e.isRunning else { return false }
-        let fmt = e.mainMixerNode.outputFormat(forBus: 0)
-        // Non-zero SR/ch and we declared the graph "hot"
-        return fmt.sampleRate > 0 && fmt.channelCount > 0 && graphState == .hot
-    }
-
-    // Prime the player with a tiny silent buffer so its first pull has data
-    private func primePlayer(_ player: AVAudioPlayerNode, engine: AVAudioEngine) {
-        let fmt = engine.mainMixerNode.outputFormat(forBus: 0)
-        guard fmt.sampleRate > 0, fmt.channelCount > 0 else { return }
-        if let buf = AVAudioPCMBuffer(pcmFormat: fmt, frameCapacity: 128) {
-            buf.frameLength = 128
-            if let ch = buf.floatChannelData {
-                memset(ch[0], 0, Int(buf.frameLength) * MemoryLayout<Float>.size)
-            }
-            player.scheduleBuffer(buf, at: nil, options: .interrupts, completionHandler: nil)
-        }
-    }
-
-    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
-
-    // MARK: - Event names (unchanged)
-    public static let supportedEvents: [String] = [
-        "onSpeechResults",
-        "onSpeechStart",
-        "onSpeechPartialResults",
-        "onSpeechError",
-        "onSpeechEnd",
-        "onSpeechRecognized",
-        "onSpeechVolumeChanged"
-    ]
-
-    // 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)
-            }
-        }
-    }
-
-    public func isRecognizing() -> Bool {
-        guard let task = recognitionTask else { return false }
-        return task.state == .running
-    }
-
-    private func rebindEngineConfigObserver(to newEngine: AVAudioEngine?) {
-        let nc = NotificationCenter.default
-        if let old = observedEngineForConfigChange {
-            nc.removeObserver(self,
-                              name: .AVAudioEngineConfigurationChange,
-                              object: old)
-        }
-        observedEngineForConfigChange = newEngine
-        if let e = newEngine {
-            nc.addObserver(self,
-                           selector: #selector(handleEngineConfigChange(_:)),
-                           name: .AVAudioEngineConfigurationChange,
-                           object: e)
-        }
-    }
-
-    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
-    }
-
-    private func rearmTask(reason: String) {
-        // 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() {
-        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"))")
-
-        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) {
-        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 btHFP = all.first { $0.portType == .bluetoothHFP }
-                let wired = all.first { $0.portType == .headsetMic }
-                let built = all.first { $0.portType == .builtInMic }
-                let best  = btHFP ?? 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) {
-        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) + 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 }
-
-        do { try session.setActive(false, options: [.notifyOthersOnDeactivation]) }
-        catch { NSLog("[STT] setActive false failed: \(error.localizedDescription)") }
-
-        // 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 []
-        }
-    }
-
-    // Add helpers
-    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
-        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()
-
-            func markIfReal(_ r: SFSpeechRecognitionResult?) {
-                guard let r = r else { return }
-                let best = r.bestTranscription.formattedString.trimmingCharacters(in: .whitespacesAndNewlines)
-                if !best.isEmpty ||
-                    r.transcriptions.contains(where: { !$0.formattedString.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) {
-                    if !self.seenRealSpeech {
-                        self.seenRealSpeech = true
-                        NSLog("first real speech detected -> onSpeechStart to JS")
-                        self.sendEvent(name: "onSpeechStart", body: nil)
-                    }
-                }
-            }
-            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
-                self.rearmTask(reason: "error")
-                return
-            }
-
-            guard let result = result else {
-                NSLog("task nil result")
-                self.rearmTask(reason: "nil-result")
-                return
-            }
-
-            let isFinal = result.isFinal
-            let parts = result.transcriptions.map { $0.formattedString }
-            self.sendResult(error: nil,
-                            bestTranscription: result.bestTranscription.formattedString,
-                            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() {
-        NSLog("[STT] teardown() begin")
-        setGraphState(.cold, why: "teardown")
-        isTearingDown = true
-        stopWatchdog()
-        consecutiveStallCount = 0
-
-        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 {
-            if engine.inputNode != nil {
-                engine.inputNode.removeTap(onBus: 0)
-                engine.inputNode.reset()
-            }
-            if engine.isRunning {
-                engine.stop()
-            }
-            engine.reset()
-            rebindEngineConfigObserver(to: nil)
-            audioEngine = nil  // Crucial step!
-        }
-
-        resetAudioSession()
-
-        sessionId = nil
-        isTearingDown = false
-    }
-
-    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 }
-
-        // (kept commented as in your code)
-        // do {
-        //     try session.setCategory(priorAudioCategory ?? .soloAmbient,
-        //                             mode: .default,
-        //                             options: [.allowBluetooth,
-        //                                       .defaultToSpeaker,
-        //                                       .allowAirPlay,
-        //                                       .mixWithOthers])
-        // } catch { }
-        audioSession = nil
-    }
-
-    // LATEST assertAEC
-    private func assertAEC(_ engine: AVAudioEngine) {
-        do { try engine.inputNode.setVoiceProcessingEnabled(true) }
-        catch { NSLog("[STT] assertAEC: setVoiceProcessingEnabled(true) failed: \(error)") }
-    }
-
-    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)
-    }
-
-    /// 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) {
-        let now = CFAbsoluteTimeGetCurrent()
-        if (now - lastReclaimAttempt) < reclaimCooldown {
-            NSLog("[STT] ensureEngineRunning(\(reason)) skipped (cooldown)")
-            return
-        }
-        lastReclaimAttempt = now
-
-        if let e = audioEngine, !e.isRunning {
-            assertAEC(e)
-            do {
-                playbackNode?.stop()
-                playbackNode = nil
-                try e.start()
-                NSLog("🔄 AVAudioEngine restarted after config change. isRunning=\(e.isRunning)")
-            } catch {
-                NSLog("❌ Could not re-start after config change: \(error)")
-            }
-        }
-
-        // --- full recovery path (this was previously dead code) ---
-        guard let engine = audioEngine else {
-            NSLog("[STT] ensureEngineRunning(\(reason)): no engine → rebuild")
-            rebuildEngineGraphAndRestart(reason: reason)
-            return
-        }
-
-        assertAEC(engine)
-
-        if !engine.isRunning {
-            setGraphState(.starting, why: "ensureEngineRunning(\(reason))")
-            do {
-                try engine.start()
-                setGraphState(.hot, why: "engine.start() ok (ensureEngineRunning)")
-                self.tryFlushPendingTTS()   // ← ADD THIS LINE
-                NSLog("[STT] ensureEngineRunning(\(reason)): engine.start() -> \(engine.isRunning)")
-            } catch {
-                setGraphState(.unstable, why: "engine.start() failed (ensureEngineRunning)")
-                NSLog("[STT] ensureEngineRunning(\(reason)): engine.start() failed: \(error) → rebuild")
-                rebuildEngineGraphAndRestart(reason: reason)
-                return
-            }
-        }
-
-        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) {
-        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 {
-                engine.inputNode.removeTap(onBus: 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
-        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
-        }
-
-        // Live format (may be 0 Hz briefly during route churn)
-        let liveFmt = newEngine.inputNode.outputFormat(forBus: 0)
-        guard liveFmt.sampleRate > 0, liveFmt.channelCount > 0 else {
-            NSLog("[STT] rebuild: input format invalid (0 Hz) — retry shortly")
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
-                self?.ensureEngineRunning(reason: "wait-valid-input-format(rebuild)")
-            }
-            return
-        }
-
-        // mic → mute mixer → mainMixer
-        let micMixer = AVAudioMixerNode()
-        newEngine.attach(micMixer)
-        // Use nil to let engine pick a valid format (avoids 0 Hz assertion)
-        newEngine.connect(inputNode, to: micMixer, format: nil)
-        newEngine.connect(micMixer, to: newEngine.mainMixerNode, format: nil)
-        micMixer.outputVolume = 0.0
-
-        // TTS player → mainMixer (keep same player if possible, else recreate)
-        if playbackNode == nil { playbackNode = AVAudioPlayerNode() }
-        if let player = playbackNode {
-            if player.engine == nil { newEngine.attach(player) }
-            newEngine.connect(player, to: newEngine.mainMixerNode, format: nil)
-        }
-        
-        do {
-            try? inputNode.removeTap(onBus: 0)
-        } catch {
-            NSLog("[STT] removeTap error: \(error)")
-        }
-
-        let targetFmt = AVAudioFormat(commonFormat: .pcmFormatFloat32,
-                                      sampleRate: 16_000,
-                                      channels: 1,
-                                      interleaved: false)!
-
-        // Tap with nil so it follows route changes automatically
-        inputNode.installTap(onBus: 0, bufferSize: 1024, format: nil) { [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])
-
-            // ---- Convert to 16 kHz MONO for STT request
-            let inFmt = buffer.format
-            if inFmt.sampleRate != 16_000 || inFmt.channelCount != 1 {
-                if let conv = AVAudioConverter(from: inFmt, to: targetFmt) {
-                    let ratio = targetFmt.sampleRate / inFmt.sampleRate
-                    let outCap = AVAudioFrameCount(Double(buffer.frameLength) * ratio) + 8
-                    if let outBuf = AVAudioPCMBuffer(pcmFormat: targetFmt, frameCapacity: outCap) {
-                        var err: NSError? = nil
-                        var fed = false
-                        conv.convert(to: outBuf, error: &err) { _, outStatus -> AVAudioBuffer? in
-                            if fed {
-                                outStatus.pointee = .endOfStream
-                                return nil
-                            } else {
-                                fed = true
-                                outStatus.pointee = .haveData
-                                return buffer
-                            }
-                        }
-                        if err == nil {
-                            self.recognitionRequest?.append(outBuf)
-                        } else {
-                            self.recognitionRequest?.append(buffer) // fallback
-                        }
-                    } else {
-                        self.recognitionRequest?.append(buffer)
-                    }
-                } else {
-                    self.recognitionRequest?.append(buffer)
-                }
-            } else {
-                self.recognitionRequest?.append(buffer)
-            }
-            self.lastBufferAt = CACurrentMediaTime()
-        }
-
-        newEngine.prepare()
-        setGraphState(.starting, why: "pre start in rebuild")
-        do {
-            try newEngine.start()
-            setGraphState(.hot, why: "engine.start() ok (rebuild)")
-            self.tryFlushPendingTTS()   // ← ADD THIS LINE
-            let f = newEngine.inputNode.outputFormat(forBus: 0)
-            NSLog("[STT] rebuild: engine.start() ok, running=\(newEngine.isRunning) (fmt=%.1f Hz / %d ch)",
-                  f.sampleRate, Int(f.channelCount))
-        } catch {
-            setGraphState(.unstable, why: "engine.start() failed (rebuild)")
-            NSLog("[STT] rebuild: engine.start() failed: \(error)")
-        }
-
-        // 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 {
-            startTask(self.recognitionRequest!)
-        }
-        rebindEngineConfigObserver(to: newEngine)
-    }
-
-    @objc private func handleEngineConfigChange(_ note: Notification) {
-        NSLog("[STT] ⚙️ AVAudioEngineConfigurationChange")
-        if playbackNode?.isPlaying == true { playbackNode?.stop() }
-        markUnstableThenRecheck(why: "AVAudioEngineConfigurationChange")
-
-        // If engine stopped, drop the player node (it will be lazily recreated)
-        if let e = audioEngine, !e.isRunning {
-            playbackNode?.stop()
-            playbackNode = nil
-        }
-
-        // Re-assert a mic-capable route (HFP/wired/built-in)
-        updateSessionRouting(selectBestInput: true)
-
-        // Re-enable VoiceProcessingIO (AEC) and restart if needed
-        ensureEngineRunning(reason: "engine-config-change")
-        self.tryFlushPendingTTS()   // ← ADD THIS LINE
-    }
-
-    @objc private func handleMediaServicesReset(_ note: Notification) {
-        NSLog("[STT] 📺 Media services were RESET: reclaiming mic & session")
-        // Re-apply audio session and try to rebuild graph if needed
-        _ = setupAudioSession()
-        ensureEngineRunning(reason: "media-services-reset")
-        self.tryFlushPendingTTS()   // ← OPTIONAL ADD
-    }
-
-    @objc private func handleRouteChange(_ note: Notification) {
-        let info = note.userInfo ?? [:]
-        NSLog("[STT] 🔀 route change: \(info)")
-        if playbackNode?.isPlaying == true { playbackNode?.stop() }
-        markUnstableThenRecheck(why: "route-change")
-
-        let s = AVAudioSession.sharedInstance()
-
-        // 1) Re-apply a mic-safe category/mode and prefer HFP/built-in mic.
-        updateSessionRouting(selectBestInput: true)
-        if let inputs = s.availableInputs {
-            let preferred = inputs.first { $0.portType == .bluetoothHFP }
-                ?? inputs.first { $0.portType == .headsetMic }
-                ?? inputs.first { $0.portType == .builtInMic }
-            try? s.setPreferredInput(preferred)
-        }
-
-        // 2) If there’s still no input, don’t thrash; wait for a usable route.
-        let inputs = s.currentRoute.inputs
-        NSLog("[STT] 🎤 inputs after route fix: \(inputs.map { $0.portType.rawValue })")
-        guard !inputs.isEmpty else {
-            NSLog("[STT] ⚠️ No mic route available (likely A2DP/AirPlay). Not restarting engine.")
-            return
-        }
-
-        // 3) Now recover the engine/task
-        ensureEngineRunning(reason: "route-change")
-        self.tryFlushPendingTTS()   // ← ADD THIS LINE
-    }
-
-    // Call once after engine is created
-    private func installEngineObservers() {
-        let nc = NotificationCenter.default
-
-        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 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):")
-        }
-    }
-
-    // Wait for one IO cycle so player won't throw "did not see an IO cycle"
-    private func awaitOneIOCycle(_ engine: AVAudioEngine,
-                                timeout: TimeInterval = 0.7,
-                                done: @escaping (Bool) -> Void) {
-        let mixer = engine.mainMixerNode
-        var fired = false
-        mixer.installTap(onBus: 0, bufferSize: 128, format: nil) { _, _ in
-            if !fired {
-                fired = true
-                mixer.removeTap(onBus: 0)
-                DispatchQueue.main.async { done(true) }
-            }
-        }
-        DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
-            if !fired {
-                mixer.removeTap(onBus: 0)
-                done(false)
-            }
-        }
-    }
-
-    private func setupAndStartRecognizing(localeStr: String?) {
-        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 = SFSpeechAudioBufferRecognitionRequest()
-        recognitionRequest = request
-
-        if #available(iOS 16, *) {
-            request.addsPunctuation = true
-        }
-        request.shouldReportPartialResults = true
-        //if #available(iOS 13.0, *) { request.taskHint = .dictation }
-        request.contextualStrings = loadContextualStrings()
-
-        guard recognitionRequest != nil else {
-            sendResult(error: ["code": "recognition_init"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            teardown()
-            return
-        }
-
-        if audioEngine == nil {
-            audioEngine = AVAudioEngine()
-            rebindEngineConfigObserver(to: audioEngine)
-        }
-        do {
-            guard let engine = audioEngine else { throw NSError(domain: "voice.audio", code: -1) }
-            let inputNode = engine.inputNode
-            _ = inputNode // presence check
-
-            // 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
-            }
-
-            NSLog("[STT] AEC enable done")
-
-            // Live format guard (can briefly be 0 Hz on route churn)
-            let liveFmt = engine.inputNode.outputFormat(forBus: 0)
-            guard liveFmt.sampleRate > 0, liveFmt.channelCount > 0 else {
-                NSLog("[STT] start: input format invalid (0 Hz) — retry shortly")
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
-                    self?.ensureEngineRunning(reason: "wait-valid-input-format(start)")
-                }
-                return
-            }
-
-            // 1) Mute only the mic path, not the whole main mixer
-            let micMixer = AVAudioMixerNode()
-            engine.attach(micMixer)
-            // Let engine choose format to avoid 0 Hz assertions
-            engine.connect(inputNode, to: micMixer, format: nil)
-            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)
-            engine.connect(player, to: engine.mainMixerNode, format: nil)
-
-            NSLog("[STT] graph connected (mic->mute mixer, player->mainMixer)")
-
-            var tapFrames: UInt64 = 0
-
-            do { try? inputNode.removeTap(onBus: 0) } catch {
-                NSLog("[STT] removeTap error: \(error)")
-            }
-
-            let targetFmt = AVAudioFormat(commonFormat: .pcmFormatFloat32,
-                                          sampleRate: 16_000,
-                                          channels: 1,
-                                          interleaved: false)!
-
-            // Tap with nil so it follows the node’s live format automatically
-            inputNode.installTap(onBus: 0, bufferSize: 1024, format: nil) { [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])
-
-                // ---- Convert to 16 kHz MONO for STT request
-                let inFmt = buffer.format
-                if inFmt.sampleRate != 16_000 || inFmt.channelCount != 1 {
-                    if let conv = AVAudioConverter(from: inFmt, to: targetFmt) {
-                        // Conservative capacity +8 frames
-                        let ratio = targetFmt.sampleRate / inFmt.sampleRate
-                        let outCap = AVAudioFrameCount(Double(buffer.frameLength) * ratio) + 8
-                        if let outBuf = AVAudioPCMBuffer(pcmFormat: targetFmt, frameCapacity: outCap) {
-                            var err: NSError? = nil
-                            var fed = false
-                            conv.convert(to: outBuf, error: &err) { _, outStatus -> AVAudioBuffer? in
-                                if fed {
-                                    outStatus.pointee = .endOfStream
-                                    return nil
-                                } else {
-                                    fed = true
-                                    outStatus.pointee = .haveData
-                                    return buffer
-                                }
-                            }
-                            if err == nil {
-                                self.recognitionRequest?.append(outBuf)
-                            } else {
-                                self.recognitionRequest?.append(buffer) // fallback
-                            }
-                        } else {
-                            self.recognitionRequest?.append(buffer)
-                        }
-                    } else {
-                        self.recognitionRequest?.append(buffer)
-                    }
-                } else {
-                    self.recognitionRequest?.append(buffer)
-                }
-
-                self.lastBufferAt = CACurrentMediaTime()
-            }
-
-            engine.prepare()
-            NSLog("[STT] audioEngine prepare")
-            setGraphState(.starting, why: "pre start in setupAndStartRecognizing")
-            var audioSessionError: NSError?
-            do {
-                try engine.start()
-                setGraphState(.hot, why: "engine.start() ok (setupAndStartRecognizing)")
-                self.tryFlushPendingTTS()   // ← ADD THIS LINE
-            } catch {
-                audioSessionError = error as NSError
-                setGraphState(.unstable, why: "engine.start() failed (setupAndStartRecognizing)")
-            }
-
-            // after engine.start() success:
-            engineHotAt = CACurrentMediaTime()
-            seenRealSpeech = false
-            let f = engine.inputNode.outputFormat(forBus: 0)
-            NSLog("engine HOT at \(engineHotAt) (fmt=%.1f Hz / %d ch)", f.sampleRate, Int(f.channelCount))
-            sendEvent(name: "onSpeechStart", body: nil) // engine hot signal
-            startTask(makeFreshRequest())
-
-            // Engine is up; expose readiness
-            AudioPlaybackHook.isEngineReady = { [weak self] in
-                guard let e = self?.audioEngine else { return false }
-                let fmt = e.mainMixerNode.outputFormat(forBus: 0)
-                return e.isRunning && fmt.sampleRate > 0 && fmt.channelCount > 0
-            }
-
-            AudioPlaybackHook.useOnlyEnginePlayback = { [weak self] in
-                guard let self = self, let e = self.audioEngine else { return false }
-                let fmt = e.mainMixerNode.outputFormat(forBus: 0)
-                return self.sttActive && e.isRunning && fmt.sampleRate > 0 && fmt.channelCount > 0
-            }
-
-            startWatchdog()
-
-            AudioPlaybackHook.engineScheduleFile = { [weak self] url, done in
-                // If STT is active we NEVER fallback; we queue until the engine is ready.
-                guard let self = self else { return true }
-
-                let scheduleOrQueue: () -> Void = {
-                    guard let engine = self.audioEngine else {
-                        // No engine yet — queue
-                        self.ttsSerial.async { self.pendingTTSSchedules.append((url, done)) }
-                        return
-                    }
-
-                    let mixFmt = engine.mainMixerNode.outputFormat(forBus: 0)
-                    let ready = engine.isRunning && mixFmt.sampleRate > 0 && mixFmt.channelCount > 0
-
-                    if ready {
-                        // Schedule immediately
-                        if self.playbackNode?.engine !== engine || !self.isPlayerConnected(self.playbackNode, to: engine) {
-                            self.playbackNode?.stop()
-                            self.playbackNode = nil
-                        }
-                        let player = self.ensurePlaybackNode(in: engine)
-                        self.primePlayer(player, engine: engine)
-                        if !player.isPlaying { player.play() }
-
-                        do {
-                            let file = try AVAudioFile(forReading: url)
-                            player.scheduleFile(file, at: nil) {
-                                DispatchQueue.main.async { done() }
-                            }
-                            NSLog("[STT] TTS: scheduled via AVAudioEngine: \(url.lastPathComponent)")
-                        } catch {
-                            NSLog("[STT] TTS schedule error: \(error) — queuing instead (no fallback).")
-                            self.ttsSerial.async { self.pendingTTSSchedules.append((url, done)) }
-                        }
-                    } else {
-                        // Not ready — queue and try to wake the engine
-                        self.ttsSerial.async { self.pendingTTSSchedules.append((url, done)) }
-
-                        // Kick the engine and wait for one IO cycle; then flush
-                        do { if !engine.isRunning { try engine.start() } } catch { }
-                        self.awaitOneIOCycle(engine, timeout: 0.7) { _ in
-                            self.tryFlushPendingTTS()
-                        }
-                    }
-                }
-
-                if Thread.isMainThread {
-                    scheduleOrQueue()
-                } else {
-                    DispatchQueue.main.async { scheduleOrQueue() }
-                }
-
-                // IMPORTANT: Always “true” while STT is active => no fallback path is taken.
-                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 {
-                NSLog("audioEngine start error: \(audioSessionError.localizedDescription)")
-                self.sendResult(error: ["code": "audio", "message": audioSessionError.localizedDescription],
-                                bestTranscription: nil, transcriptions: nil, isFinal: nil)
-                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"))")
-    }
-}