react-native-davoice-tts 1.0.217 → 1.0.219

package/ios/TTSRNBridge/DavoiceTTS.xcframework/ios-arm64/DavoiceTTS.framework/DaVoiceSTT.swift__

@@ -1,1329 +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 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"))")
-    }
-}