@garrix82/reactgenie-lib 1.3.0

package/dist/speech-recognition/speech-recognition-native.js

@@ -0,0 +1,632 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativeSpeechRecognizer = void 0;
+exports.getNativeSpeechCapabilities = getNativeSpeechCapabilities;
+exports.isNativeSpeechAvailable = isNativeSpeechAvailable;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+var _logger = _interopRequireDefault(require("../logger"));
+var _groqTranscription = require("./utils/groq-transcription");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Native Speech Recognition (iOS/Android)
+ * Uses Expo Audio for recording and Groq for transcription
+ *
+ * REQUIRES: expo-audio + expo-file-system (SDK 53+)
+ */
+
+const FileSystem = (() => {
+  try {
+    // Prefer legacy API when available (Expo SDK 54+ warns on direct legacy usage)
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('expo-file-system/legacy');
+  } catch {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('expo-file-system');
+  }
+})();
+const missingAudioError = 'Native audio package not found. Install `expo-audio` and `expo-file-system`, then run a dev client build: npx expo install expo-audio expo-file-system';
+function loadExpoAudioBackend() {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const expoAudio = require('expo-audio');
+    const AudioModule = expoAudio?.AudioModule;
+    const requestRecordingPermissionsAsync = expoAudio?.requestRecordingPermissionsAsync;
+    const setAudioModeAsync = expoAudio?.setAudioModeAsync;
+    if (!AudioModule || typeof requestRecordingPermissionsAsync !== 'function' || typeof setAudioModeAsync !== 'function') {
+      return null;
+    }
+    const RecordingPresets = expoAudio?.RecordingPresets;
+    const AudioQuality = expoAudio?.AudioQuality;
+    const IOSOutputFormat = expoAudio?.IOSOutputFormat;
+    const preset = RecordingPresets?.HIGH_QUALITY;
+    const iosOutputFormat = IOSOutputFormat?.MPEG4AAC ?? 'aac ';
+    const iosAudioQuality = AudioQuality?.HIGH ?? 0x60;
+    const recordingOptions = {
+      extension: preset?.extension ?? '.m4a',
+      sampleRate: 16000,
+      numberOfChannels: 1,
+      bitRate: 128000,
+      android: {
+        outputFormat: preset?.android?.outputFormat ?? 'mpeg4',
+        audioEncoder: preset?.android?.audioEncoder ?? 'aac',
+        sampleRate: 16000,
+        numberOfChannels: 1,
+        bitRate: 128000
+      },
+      ios: {
+        outputFormat: preset?.ios?.outputFormat ?? iosOutputFormat,
+        audioQuality: preset?.ios?.audioQuality ?? iosAudioQuality,
+        sampleRate: 16000,
+        numberOfChannels: 1,
+        bitRate: 128000,
+        linearPCMBitDepth: 16,
+        linearPCMIsBigEndian: false,
+        linearPCMIsFloat: false
+      },
+      web: {
+        mimeType: preset?.web?.mimeType ?? 'audio/webm',
+        bitsPerSecond: preset?.web?.bitsPerSecond ?? 128000
+      }
+    };
+    return {
+      kind: 'expo-audio',
+      requestPermissionsAsync: requestRecordingPermissionsAsync,
+      setAudioModeAsync,
+      createRecording: () => new AudioModule.AudioRecorder(recordingOptions),
+      prepareToRecordAsync: recording => recording.prepareToRecordAsync(),
+      startAsync: async recording => {
+        recording.record();
+      },
+      stopAsync: async recording => {
+        await recording.stop();
+        return {
+          uri: recording?.uri ?? null
+        };
+      },
+      getUri: (recording, stopResult) => {
+        if (stopResult?.uri) return stopResult.uri;
+        return recording?.uri ?? null;
+      }
+    };
+  } catch (e) {
+    return null;
+  }
+}
+const audioBackend = loadExpoAudioBackend();
+if (!audioBackend) {
+  _logger.default.error('❌ No audio backend available. Install expo-audio + expo-file-system and run a dev client build.');
+} else {
+  _logger.default.info(`🎤 Audio backend ready: ${audioBackend.kind}`);
+}
+const DEFAULT_CHUNK_DURATION_MS = 2000; // Reduced from 3000ms for better responsiveness while maintaining efficiency
+const START_RETRY_DELAY_MS = 150;
+const POST_STOP_COOLDOWN_MS = 120;
+const MAX_START_ATTEMPTS = 3;
+const MAX_CONSECUTIVE_START_FAILURES = 3;
+const MIN_AUDIO_SIZE_FLOOR_BYTES = 256;
+/**
+ * Native speech recognizer for iOS/Android using expo-audio
+ */
+const NativeSpeechRecognizer = ({
+  shouldListen,
+  speechStatusCallback,
+  speechResultCallback,
+  speechTranslationCallback,
+  clientSecret,
+  groqApiBaseUrl,
+  groqTranscriptionEndpoint,
+  stream = true,
+  language = 'en',
+  onError,
+  minAudioSize = 500
+}) => {
+  const [isRecording, setIsRecording] = (0, _react.useState)(false);
+  const activeRecordingRef = (0, _react.useRef)(null);
+  const stopInFlightRef = (0, _react.useRef)(null);
+  const chunkLoopAbortRef = (0, _react.useRef)(null);
+  const streamAbortRef = (0, _react.useRef)(null);
+  const activeChunksRef = (0, _react.useRef)(new Set());
+  const committedTranscriptRef = (0, _react.useRef)('');
+  const currentChunkTranscriptRef = (0, _react.useRef)('');
+  const lastInterimRef = (0, _react.useRef)('');
+  (0, _react.useEffect)(() => {
+    if (clientSecret) {
+      _logger.default.debug('Groq client initialized (native)');
+    }
+  }, [clientSecret]);
+
+  /**
+   * Request audio permissions
+   */
+  const requestPermissions = async () => {
+    try {
+      if (!audioBackend) {
+        throw new Error(missingAudioError);
+      }
+      _logger.default.info('Requesting microphone permissions...');
+      const {
+        status,
+        granted
+      } = await audioBackend.requestPermissionsAsync();
+      const isGranted = status === 'granted' || granted === true;
+      if (!isGranted) {
+        throw new Error('Audio permission not granted. Please enable microphone access in your device settings.');
+      }
+      _logger.default.info('✅ Microphone permission granted');
+      return true;
+    } catch (error) {
+      _logger.default.error('Permission error:', error);
+      if (onError) {
+        onError(error);
+      }
+      return false;
+    }
+  };
+  const resetTranscriptState = (0, _react.useCallback)(() => {
+    committedTranscriptRef.current = '';
+    currentChunkTranscriptRef.current = '';
+    lastInterimRef.current = '';
+  }, []);
+  const commitChunk = (0, _react.useCallback)(chunkText => {
+    const combined = (0, _groqTranscription.mergeTranscriptParts)(committedTranscriptRef.current, chunkText);
+    committedTranscriptRef.current = combined;
+    currentChunkTranscriptRef.current = '';
+  }, []);
+  const stopRecorderSafely = (0, _react.useCallback)(async (recording, reason) => {
+    if (!audioBackend || !recording) {
+      return null;
+    }
+    const inFlight = stopInFlightRef.current;
+    if (inFlight && inFlight.recording === recording) {
+      _logger.default.debug(`[NativeSR] ♻️  Reusing in-flight stop (${reason})`);
+      return inFlight.promise;
+    }
+    const stopPromise = (async () => {
+      try {
+        const stopResult = await audioBackend.stopAsync(recording);
+        return audioBackend.getUri(recording, stopResult);
+      } catch (error) {
+        if (isBenignStopError(error)) {
+          _logger.default.debug(`[NativeSR] Stop already finalized (${reason})`);
+          return audioBackend.getUri(recording);
+        }
+        throw error;
+      } finally {
+        if (stopInFlightRef.current?.recording === recording) {
+          stopInFlightRef.current = null;
+        }
+      }
+    })();
+    stopInFlightRef.current = {
+      recording,
+      promise: stopPromise
+    };
+    return stopPromise;
+  }, []);
+
+  /**
+   * Process recorded audio chunk and send to Groq (streaming)
+   */
+  const processAudioChunk = (0, _react.useCallback)(async fileUri => {
+    let normalizedUri;
+    try {
+      _logger.default.debug('[NativeSR] 🔍 Processing audio chunk:', fileUri);
+      normalizedUri = normalizeFileUri(fileUri);
+      _logger.default.debug('[NativeSR] 📁 Normalized URI:', normalizedUri);
+
+      // Read file
+      _logger.default.debug('[NativeSR] 📖 Reading file info...');
+      const fileInfo = await FileSystem.getInfoAsync(normalizedUri);
+      _logger.default.debug('[NativeSR] 📊 File info:', JSON.stringify(fileInfo));
+      if (!fileInfo.exists) {
+        _logger.default.error('[NativeSR] ❌ Audio file missing:', normalizedUri);
+        return;
+      }
+      const fileSize = 'size' in fileInfo && typeof fileInfo.size === 'number' ? fileInfo.size : null;
+      const effectiveMinAudioSize = Math.max(minAudioSize, MIN_AUDIO_SIZE_FLOOR_BYTES);
+      if (fileSize !== null && fileSize < effectiveMinAudioSize) {
+        _logger.default.warn(`[NativeSR] ⚠️  Audio file too small (${fileSize} bytes, min: ${effectiveMinAudioSize})`);
+        return;
+      }
+      _logger.default.info(`[NativeSR] 📤 Uploading ${fileSize ?? 'unknown'} bytes to Groq...`);
+      const fileName = getFileNameFromUri(normalizedUri);
+      const mimeType = getMimeTypeFromName(fileName);
+      const controller = new AbortController();
+      streamAbortRef.current = controller;
+      const chunkText = await (0, _groqTranscription.streamGroqTranscription)({
+        apiKey: clientSecret,
+        audioBlob: {
+          uri: normalizedUri,
+          name: fileName,
+          type: mimeType
+        },
+        mimeType,
+        language,
+        responseFormat: 'verbose_json',
+        stream,
+        endpoint: resolveGroqTranscriptionEndpoint(groqApiBaseUrl, groqTranscriptionEndpoint),
+        signal: controller.signal,
+        onInterim: text => {
+          if (!text) return;
+          _logger.default.debug(`[NativeSR] 📝 Interim chunk text (${text.length} chars)`);
+          currentChunkTranscriptRef.current = text;
+
+          // Real-time callback like web version
+          const combined = (0, _groqTranscription.mergeTranscriptParts)(committedTranscriptRef.current, text);
+          if (combined !== lastInterimRef.current) {
+            lastInterimRef.current = combined;
+            speechStatusCallback(true, combined);
+          }
+        }
+      });
+      if (chunkText) {
+        _logger.default.info(`[NativeSR] ✅ Chunk transcription complete (${chunkText.length} chars)`);
+        commitChunk(chunkText);
+        // Final update after chunk completes
+        const finalCombined = (0, _groqTranscription.mergeTranscriptParts)(committedTranscriptRef.current, '');
+        if (finalCombined !== lastInterimRef.current) {
+          lastInterimRef.current = finalCombined;
+          speechStatusCallback(true, finalCombined);
+        }
+      }
+    } catch (error) {
+      _logger.default.error('[NativeSR] Groq transcription error:', error);
+      if (onError) {
+        onError(error);
+      }
+    } finally {
+      try {
+        if (normalizedUri) {
+          await FileSystem.deleteAsync(normalizedUri, {
+            idempotent: true
+          });
+        }
+      } catch (error) {
+        _logger.default.warn('[NativeSR] Failed to delete temp audio file:', error);
+      }
+    }
+  }, [commitChunk, clientSecret, groqApiBaseUrl, groqTranscriptionEndpoint, stream, language, minAudioSize, onError]);
+
+  /**
+   * Start chunked recording loop for streaming transcription
+   */
+  const startChunkLoop = (0, _react.useCallback)(async () => {
+    if (!audioBackend) return;
+    const controller = new AbortController();
+    chunkLoopAbortRef.current = controller;
+    _logger.default.info(`[NativeSR] 🔄 Chunk loop started (${DEFAULT_CHUNK_DURATION_MS}ms chunks)`);
+    let chunkCount = 0;
+    let consecutiveStartFailures = 0;
+    while (!controller.signal.aborted) {
+      chunkCount++;
+      _logger.default.debug(`[NativeSR] 📼 Recording chunk #${chunkCount}...`);
+      let recording = null;
+      let started = false;
+      for (let attempt = 1; attempt <= MAX_START_ATTEMPTS; attempt++) {
+        if (controller.signal.aborted) {
+          break;
+        }
+        recording = audioBackend.createRecording();
+        activeRecordingRef.current = recording;
+        try {
+          await audioBackend.prepareToRecordAsync(recording);
+          await audioBackend.startAsync(recording);
+          _logger.default.debug(`[NativeSR] 🎙️  Chunk #${chunkCount} recording...`);
+          started = true;
+          break;
+        } catch (error) {
+          _logger.default.error(`Failed to start chunk #${chunkCount} recording (attempt ${attempt}/${MAX_START_ATTEMPTS}):`, error);
+          activeRecordingRef.current = null;
+          if (attempt < MAX_START_ATTEMPTS) {
+            await sleep(START_RETRY_DELAY_MS);
+          }
+        }
+      }
+      if (!started || !recording) {
+        consecutiveStartFailures += 1;
+        _logger.default.warn(`[NativeSR] ⚠️  Chunk start failed (${consecutiveStartFailures}/${MAX_CONSECUTIVE_START_FAILURES}).`);
+        if (consecutiveStartFailures >= MAX_CONSECUTIVE_START_FAILURES) {
+          _logger.default.error('[NativeSR] ❌ Too many consecutive chunk start failures; ending loop.');
+          break;
+        }
+        await sleep(START_RETRY_DELAY_MS);
+        continue;
+      }
+      consecutiveStartFailures = 0;
+      await sleep(DEFAULT_CHUNK_DURATION_MS);
+      if (controller.signal.aborted) {
+        _logger.default.info('[NativeSR] 🛑 Chunk loop aborted');
+        const stillActive = activeRecordingRef.current === recording;
+        if (stillActive) {
+          try {
+            const uri = await stopRecorderSafely(recording, `abort chunk #${chunkCount}`);
+            if (uri) {
+              _logger.default.info(`[NativeSR] ✅ Final chunk URI (abort): ${uri.substring(0, 50)}...`);
+              const chunkPromise = processAudioChunk(uri).catch(error => {
+                _logger.default.error('[NativeSR] Failed to process aborted chunk:', error);
+              }).finally(() => {
+                activeChunksRef.current.delete(chunkPromise);
+              });
+              activeChunksRef.current.add(chunkPromise);
+            } else {
+              _logger.default.warn('[NativeSR] ⚠️  No URI for aborted chunk - skipping upload');
+            }
+          } catch (error) {
+            _logger.default.warn('[NativeSR] Failed to stop chunk recording on abort:', error);
+          }
+        } else {
+          _logger.default.debug('[NativeSR] Abort detected after external stop; skipping duplicate stop');
+        }
+        activeRecordingRef.current = null;
+        break;
+      }
+      try {
+        _logger.default.debug(`[NativeSR] ⏹️  Stopping chunk #${chunkCount}...`);
+        const uri = await stopRecorderSafely(recording, `chunk #${chunkCount}`);
+        _logger.default.debug(`[NativeSR] ✅ Chunk #${chunkCount} stopped`);
+        activeRecordingRef.current = null;
+        if (uri) {
+          _logger.default.info(`[NativeSR] ✅ Chunk #${chunkCount} URI: ${uri.substring(0, 50)}...`);
+          // Process chunks truly in parallel - track active chunks
+          const chunkPromise = processAudioChunk(uri).catch(error => {
+            _logger.default.error(`[NativeSR] Failed to process chunk #${chunkCount}:`, error);
+          }).finally(() => {
+            activeChunksRef.current.delete(chunkPromise);
+          });
+          activeChunksRef.current.add(chunkPromise);
+        } else {
+          _logger.default.warn(`[NativeSR] ⚠️  No URI for chunk #${chunkCount} - skipping upload`);
+        }
+      } catch (error) {
+        _logger.default.error(`[NativeSR] Failed to stop chunk #${chunkCount}:`, error);
+        activeRecordingRef.current = null;
+        continue; // Skip this chunk, try next one
+      }
+      if (!controller.signal.aborted) {
+        await sleep(POST_STOP_COOLDOWN_MS);
+      }
+    }
+    _logger.default.info(`[NativeSR] 🏁 Chunk loop ended (processed ${chunkCount} chunks)`);
+  }, [processAudioChunk, stopRecorderSafely]);
+
+  /**
+   * Start audio recording
+   */
+  const startRecording = (0, _react.useCallback)(async () => {
+    try {
+      if (!audioBackend) {
+        throw new Error(missingAudioError);
+      }
+      _logger.default.info(`[NativeSR] Start recording (backend=${audioBackend.kind})`);
+
+      // Request permissions
+      const hasPermission = await requestPermissions();
+      if (!hasPermission) {
+        _logger.default.warn('[NativeSR] Permission denied');
+        speechStatusCallback(false, '');
+        return;
+      }
+      await audioBackend.setAudioModeAsync({
+        allowsRecording: true,
+        playsInSilentMode: true,
+        shouldPlayInBackground: false,
+        shouldRouteThroughEarpiece: false,
+        interruptionMode: 'duckOthers'
+      });
+      _logger.default.debug('[NativeSR] Audio mode configured');
+      resetTranscriptState();
+      setIsRecording(true);
+      speechStatusCallback(true, '');
+      _logger.default.info('[NativeSR] 🎤 Native recording started');
+      startChunkLoop();
+    } catch (error) {
+      _logger.default.error('[NativeSR] Failed to start native recording:', error);
+      if (onError) {
+        onError(error);
+      }
+      speechStatusCallback(false, '');
+    }
+  }, [speechStatusCallback, onError, resetTranscriptState, startChunkLoop]);
+
+  /**
+   * Stop audio recording
+   */
+  const stopRecording = (0, _react.useCallback)(async () => {
+    if (!isRecording || !audioBackend) return;
+    try {
+      _logger.default.info('[NativeSR] Stop recording requested');
+      if (chunkLoopAbortRef.current) {
+        chunkLoopAbortRef.current.abort();
+        chunkLoopAbortRef.current = null;
+      }
+      if (activeRecordingRef.current) {
+        const currentRecording = activeRecordingRef.current;
+        activeRecordingRef.current = null;
+        try {
+          _logger.default.info('[NativeSR] ⏹️  Stopping final active recording...');
+          const uri = await stopRecorderSafely(currentRecording, 'explicit stop');
+          if (uri) {
+            _logger.default.info('[NativeSR] ✅ Final recording URI:', uri);
+            const chunkPromise = processAudioChunk(uri).catch(error => {
+              _logger.default.error('[NativeSR] Failed to process final chunk:', error);
+            }).finally(() => {
+              activeChunksRef.current.delete(chunkPromise);
+            });
+            activeChunksRef.current.add(chunkPromise);
+          } else {
+            _logger.default.warn('[NativeSR] ⚠️  No URI from final recording');
+          }
+        } catch (error) {
+          _logger.default.warn('[NativeSR] Failed to stop active recording:', error);
+        }
+      }
+      setIsRecording(false);
+
+      // Wait for all active chunks to complete (truly parallel)
+      try {
+        _logger.default.info(`[NativeSR] ⏳ Waiting for ${activeChunksRef.current.size} active chunks to complete...`);
+        await Promise.all(Array.from(activeChunksRef.current));
+        _logger.default.info('[NativeSR] ✅ All chunks processed');
+      } catch (error) {
+        _logger.default.warn('[NativeSR] Some chunks failed:', error);
+      }
+      const finalText = committedTranscriptRef.current || currentChunkTranscriptRef.current;
+      if (speechTranslationCallback && finalText && language && !language.startsWith('en')) {
+        try {
+          const translated = await (0, _groqTranscription.translateGroqText)({
+            apiKey: clientSecret,
+            text: finalText,
+            language,
+            endpoint: resolveGroqChatEndpoint(groqApiBaseUrl)
+          });
+          if (translated) {
+            speechTranslationCallback(translated);
+          }
+        } catch (error) {
+          _logger.default.warn('[NativeSR] Groq translation failed:', error);
+        }
+      }
+      _logger.default.info(`[NativeSR] Final text length: ${finalText.length}`);
+      speechStatusCallback(false, '');
+      if (finalText) {
+        speechResultCallback(finalText);
+      }
+      resetTranscriptState();
+    } catch (error) {
+      _logger.default.error('[NativeSR] Failed to stop native recording:', error);
+      if (onError) {
+        onError(error);
+      }
+      speechStatusCallback(false, '');
+    }
+  }, [isRecording, clientSecret, groqApiBaseUrl, language, onError, processAudioChunk, resetTranscriptState, speechResultCallback, speechStatusCallback, speechTranslationCallback, stopRecorderSafely]);
+
+  /**
+   * Handle shouldListen prop changes
+   */
+  (0, _react.useEffect)(() => {
+    _logger.default.debug(`[NativeSR] shouldListen=${shouldListen} isRecording=${isRecording}`);
+    if (shouldListen && !isRecording) {
+      startRecording();
+    } else if (!shouldListen && isRecording) {
+      stopRecording();
+    }
+  }, [shouldListen, isRecording, startRecording, stopRecording]);
+
+  /**
+   * Cleanup on unmount
+   */
+  (0, _react.useEffect)(() => {
+    return () => {
+      if (chunkLoopAbortRef.current) {
+        _logger.default.info('[NativeSR] Cleanup: aborting chunk loop');
+        chunkLoopAbortRef.current.abort();
+      }
+      if (streamAbortRef.current) {
+        _logger.default.info('[NativeSR] Cleanup: aborting stream');
+        streamAbortRef.current.abort();
+      }
+      if (activeRecordingRef.current && audioBackend) {
+        _logger.default.info('[NativeSR] Cleanup: stopping active recording');
+        stopRecorderSafely(activeRecordingRef.current, 'cleanup').catch(() => undefined);
+      }
+    };
+  }, [stopRecorderSafely]);
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, null);
+};
+exports.NativeSpeechRecognizer = NativeSpeechRecognizer;
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+function isBenignStopError(error) {
+  const message = error instanceof Error ? error.message : typeof error === 'string' ? error : '';
+  return /stop failed|already|not recording/i.test(message);
+}
+
+/**
+ * Convert base64 string to Blob
+ */
+function getFileNameFromUri(uri) {
+  const cleanUri = uri.split('?')[0];
+  const lastSlash = cleanUri.lastIndexOf('/');
+  const fileName = lastSlash >= 0 ? cleanUri.slice(lastSlash + 1) : cleanUri;
+  if (fileName && fileName.includes('.')) {
+    return fileName;
+  }
+  return `audio-${Date.now()}.m4a`;
+}
+function getMimeTypeFromName(name) {
+  const ext = name.split('.').pop()?.toLowerCase() || '';
+  switch (ext) {
+    case 'm4a':
+      return 'audio/m4a';
+    case 'aac':
+      return 'audio/aac';
+    case 'mp3':
+      return 'audio/mpeg';
+    case 'mp4':
+      return 'audio/mp4';
+    case 'wav':
+      return 'audio/wav';
+    case 'webm':
+      return 'audio/webm';
+    case 'ogg':
+      return 'audio/ogg';
+    default:
+      return 'audio/m4a';
+  }
+}
+function resolveGroqTranscriptionEndpoint(baseUrl, overrideEndpoint) {
+  if (overrideEndpoint) return overrideEndpoint;
+  if (!baseUrl) return undefined;
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  if (trimmed.endsWith('/openai/v1')) {
+    return `${trimmed}/audio/transcriptions`;
+  }
+  return `${trimmed}/openai/v1/audio/transcriptions`;
+}
+function resolveGroqChatEndpoint(baseUrl) {
+  if (!baseUrl) return undefined;
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  if (trimmed.endsWith('/openai/v1')) {
+    return `${trimmed}/chat/completions`;
+  }
+  return `${trimmed}/openai/v1/chat/completions`;
+}
+function normalizeFileUri(uri) {
+  if (!uri) return uri;
+  if (uri.startsWith('file://') || uri.startsWith('content://')) {
+    return uri;
+  }
+  if (uri.startsWith('/')) {
+    return `file://${uri}`;
+  }
+  return uri;
+}
+
+/**
+ * Check if native speech recognition is available
+ */
+function isNativeSpeechAvailable() {
+  return (_reactNative.Platform.OS === 'ios' || _reactNative.Platform.OS === 'android') && !!audioBackend;
+}
+
+/**
+ * Get native speech capabilities
+ */
+function getNativeSpeechCapabilities() {
+  return {
+    available: isNativeSpeechAvailable(),
+    platform: _reactNative.Platform.OS,
+    supportsVAD: true,
+    supportsAudioLevels: true,
+    requiresExpoAudio: true,
+    backend: audioBackend?.kind ?? 'none'
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNative","_logger","_interopRequireDefault","_groqTranscription","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","FileSystem","missingAudioError","loadExpoAudioBackend","expoAudio","AudioModule","requestRecordingPermissionsAsync","setAudioModeAsync","RecordingPresets","AudioQuality","IOSOutputFormat","preset","HIGH_QUALITY","iosOutputFormat","MPEG4AAC","iosAudioQuality","HIGH","recordingOptions","extension","sampleRate","numberOfChannels","bitRate","android","outputFormat","audioEncoder","ios","audioQuality","linearPCMBitDepth","linearPCMIsBigEndian","linearPCMIsFloat","web","mimeType","bitsPerSecond","kind","requestPermissionsAsync","createRecording","AudioRecorder","prepareToRecordAsync","recording","startAsync","record","stopAsync","stop","uri","getUri","stopResult","audioBackend","logger","error","info","DEFAULT_CHUNK_DURATION_MS","START_RETRY_DELAY_MS","POST_STOP_COOLDOWN_MS","MAX_START_ATTEMPTS","MAX_CONSECUTIVE_START_FAILURES","MIN_AUDIO_SIZE_FLOOR_BYTES","NativeSpeechRecognizer","shouldListen","speechStatusCallback","speechResultCallback","speechTranslationCallback","clientSecret","groqApiBaseUrl","groqTranscriptionEndpoint","stream","language","onError","minAudioSize","isRecording","setIsRecording","useState","activeRecordingRef","useRef","stopInFlightRef","chunkLoopAbortRef","streamAbortRef","activeChunksRef","Set","committedTranscriptRef","currentChunkTranscriptRef","lastInterimRef","useEffect","debug","requestPermissions","Error","status","granted","isGranted","resetTranscriptState","useCallback","current","commitChunk","chunkText","combined","mergeTranscriptParts","stopRecorderSafely","reason","inFlight","promise","stopPromise","isBenignStopError","processAudioChunk","fileUri","normalizedUri","normalizeFileUri","fileInfo","getInfoAsync","JSON","stringify","exists","fileSize","size","effectiveMinAudioSize","Math","max","warn","fileName","getFileNameFromUri","getMimeTypeFromName","controller","AbortController","streamGroqTranscription","apiKey","audioBlob","name","type","responseFormat","endpoint","resolveGroqTranscriptionEndpoint","signal","onInterim","text","length","finalCombined","deleteAsync","idempotent","startChunkLoop","chunkCount","consecutiveStartFailures","aborted","started","attempt","sleep","stillActive","substring","chunkPromise","catch","finally","delete","add","startRecording","hasPermission","allowsRecording","playsInSilentMode","shouldPlayInBackground","shouldRouteThroughEarpiece","interruptionMode","stopRecording","abort","currentRecording","Promise","all","Array","from","finalText","startsWith","translated","translateGroqText","resolveGroqChatEndpoint","undefined","createElement","View","exports","ms","resolve","setTimeout","message","test","cleanUri","split","lastSlash","lastIndexOf","slice","includes","Date","now","ext","pop","toLowerCase","baseUrl","overrideEndpoint","trimmed","replace","endsWith","isNativeSpeechAvailable","Platform","OS","getNativeSpeechCapabilities","available","platform","supportsVAD","supportsAudioLevels","requiresExpoAudio","backend"],"sources":["../../src/speech-recognition/speech-recognition-native.tsx"],"sourcesContent":["/**\n * Native Speech Recognition (iOS/Android)\n * Uses Expo Audio for recording and Groq for transcription\n *\n * REQUIRES: expo-audio + expo-file-system (SDK 53+)\n */\n\nimport React, { useEffect, useState, useRef, useCallback } from 'react';\nimport { View, Platform } from 'react-native';\ntype FileSystemModule = typeof import('expo-file-system');\n\nconst FileSystem: FileSystemModule = (() => {\n  try {\n    // Prefer legacy API when available (Expo SDK 54+ warns on direct legacy usage)\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    return require('expo-file-system/legacy');\n  } catch {\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    return require('expo-file-system');\n  }\n})();\nimport logger from '../logger';\nimport {\n  mergeTranscriptParts,\n  streamGroqTranscription,\n  translateGroqText,\n} from './utils/groq-transcription';\n\ntype AudioBackend = {\n  kind: 'expo-audio';\n  requestPermissionsAsync: () => Promise<{ status?: string; granted?: boolean }>;\n  setAudioModeAsync: (mode: any) => Promise<void>;\n  createRecording: () => any;\n  prepareToRecordAsync: (recording: any) => Promise<void>;\n  startAsync: (recording: any) => Promise<void>;\n  stopAsync: (recording: any) => Promise<{ uri?: string | null } | void>;\n  getUri: (recording: any, stopResult?: any) => string | null;\n};\n\nconst missingAudioError =\n  'Native audio package not found. Install `expo-audio` and `expo-file-system`, then run a dev client build: npx expo install expo-audio expo-file-system';\n\nfunction loadExpoAudioBackend(): AudioBackend | null {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    const expoAudio = require('expo-audio');\n    const AudioModule = expoAudio?.AudioModule;\n    const requestRecordingPermissionsAsync = expoAudio?.requestRecordingPermissionsAsync;\n    const setAudioModeAsync = expoAudio?.setAudioModeAsync;\n\n    if (!AudioModule || typeof requestRecordingPermissionsAsync !== 'function' || typeof setAudioModeAsync !== 'function') {\n      return null;\n    }\n\n    const RecordingPresets = expoAudio?.RecordingPresets;\n    const AudioQuality = expoAudio?.AudioQuality;\n    const IOSOutputFormat = expoAudio?.IOSOutputFormat;\n\n    const preset = RecordingPresets?.HIGH_QUALITY;\n    const iosOutputFormat = IOSOutputFormat?.MPEG4AAC ?? 'aac ';\n    const iosAudioQuality = AudioQuality?.HIGH ?? 0x60;\n\n    const recordingOptions = {\n      extension: preset?.extension ?? '.m4a',\n      sampleRate: 16000,\n      numberOfChannels: 1,\n      bitRate: 128000,\n      android: {\n        outputFormat: preset?.android?.outputFormat ?? 'mpeg4',\n        audioEncoder: preset?.android?.audioEncoder ?? 'aac',\n        sampleRate: 16000,\n        numberOfChannels: 1,\n        bitRate: 128000,\n      },\n      ios: {\n        outputFormat: preset?.ios?.outputFormat ?? iosOutputFormat,\n        audioQuality: preset?.ios?.audioQuality ?? iosAudioQuality,\n        sampleRate: 16000,\n        numberOfChannels: 1,\n        bitRate: 128000,\n        linearPCMBitDepth: 16,\n        linearPCMIsBigEndian: false,\n        linearPCMIsFloat: false,\n      },\n      web: {\n        mimeType: preset?.web?.mimeType ?? 'audio/webm',\n        bitsPerSecond: preset?.web?.bitsPerSecond ?? 128000,\n      },\n    };\n\n    return {\n      kind: 'expo-audio',\n      requestPermissionsAsync: requestRecordingPermissionsAsync,\n      setAudioModeAsync,\n      createRecording: () => new AudioModule.AudioRecorder(recordingOptions),\n      prepareToRecordAsync: (recording) => recording.prepareToRecordAsync(),\n      startAsync: async (recording) => {\n        recording.record();\n      },\n      stopAsync: async (recording) => {\n        await recording.stop();\n        return { uri: recording?.uri ?? null };\n      },\n      getUri: (recording, stopResult) => {\n        if (stopResult?.uri) return stopResult.uri;\n        return recording?.uri ?? null;\n      },\n    };\n  } catch (e) {\n    return null;\n  }\n}\n\nconst audioBackend: AudioBackend | null = loadExpoAudioBackend();\n\nif (!audioBackend) {\n  logger.error(\n    '❌ No audio backend available. Install expo-audio + expo-file-system and run a dev client build.',\n  );\n} else {\n  logger.info(`🎤 Audio backend ready: ${audioBackend.kind}`);\n}\n\nconst DEFAULT_CHUNK_DURATION_MS = 2000; // Reduced from 3000ms for better responsiveness while maintaining efficiency\nconst START_RETRY_DELAY_MS = 150;\nconst POST_STOP_COOLDOWN_MS = 120;\nconst MAX_START_ATTEMPTS = 3;\nconst MAX_CONSECUTIVE_START_FAILURES = 3;\nconst MIN_AUDIO_SIZE_FLOOR_BYTES = 256;\n\nexport interface NativeSpeechRecognizerProps {\n  shouldListen: boolean;\n  speechStatusCallback: (status: boolean, transcript: string) => void;\n  speechResultCallback: (result: string) => void;\n  speechTranslationCallback?: (translation: string) => void;\n  clientSecret: string;\n  groqApiBaseUrl?: string;\n  groqTranscriptionEndpoint?: string;\n  stream?: boolean;\n  language?: string;\n  onError?: (error: Error) => void;\n  minAudioSize?: number; // Minimum audio size in bytes (default 1000)\n}\n\n/**\n * Native speech recognizer for iOS/Android using expo-audio\n */\nexport const NativeSpeechRecognizer: React.FC<NativeSpeechRecognizerProps> = ({\n  shouldListen,\n  speechStatusCallback,\n  speechResultCallback,\n  speechTranslationCallback,\n  clientSecret,\n  groqApiBaseUrl,\n  groqTranscriptionEndpoint,\n  stream = true,\n  language = 'en',\n  onError,\n  minAudioSize = 500,\n}) => {\n  const [isRecording, setIsRecording] = useState(false);\n  const activeRecordingRef = useRef<any>(null);\n  const stopInFlightRef = useRef<{ recording: any; promise: Promise<string | null> } | null>(null);\n  const chunkLoopAbortRef = useRef<AbortController | null>(null);\n  const streamAbortRef = useRef<AbortController | null>(null);\n  const activeChunksRef = useRef<Set<Promise<void>>>(new Set());\n  const committedTranscriptRef = useRef<string>('');\n  const currentChunkTranscriptRef = useRef<string>('');\n  const lastInterimRef = useRef<string>('');\n\n  useEffect(() => {\n    if (clientSecret) {\n      logger.debug('Groq client initialized (native)');\n    }\n  }, [clientSecret]);\n\n  /**\n   * Request audio permissions\n   */\n  const requestPermissions = async () => {\n    try {\n      if (!audioBackend) {\n        throw new Error(missingAudioError);\n      }\n      logger.info('Requesting microphone permissions...');\n      const { status, granted } = await audioBackend.requestPermissionsAsync();\n      const isGranted = status === 'granted' || granted === true;\n      if (!isGranted) {\n        throw new Error('Audio permission not granted. Please enable microphone access in your device settings.');\n      }\n      logger.info('✅ Microphone permission granted');\n      return true;\n    } catch (error) {\n      logger.error('Permission error:', error);\n      if (onError) {\n        onError(error as Error);\n      }\n      return false;\n    }\n  };\n\n  const resetTranscriptState = useCallback(() => {\n    committedTranscriptRef.current = '';\n    currentChunkTranscriptRef.current = '';\n    lastInterimRef.current = '';\n  }, []);\n\n  const commitChunk = useCallback((chunkText: string) => {\n    const combined = mergeTranscriptParts(\n      committedTranscriptRef.current,\n      chunkText\n    );\n    committedTranscriptRef.current = combined;\n    currentChunkTranscriptRef.current = '';\n  }, []);\n\n  const stopRecorderSafely = useCallback(\n    async (recording: any, reason: string): Promise<string | null> => {\n      if (!audioBackend || !recording) {\n        return null;\n      }\n\n      const inFlight = stopInFlightRef.current;\n      if (inFlight && inFlight.recording === recording) {\n        logger.debug(`[NativeSR] ♻️  Reusing in-flight stop (${reason})`);\n        return inFlight.promise;\n      }\n\n      const stopPromise = (async () => {\n        try {\n          const stopResult = await audioBackend.stopAsync(recording);\n          return audioBackend.getUri(recording, stopResult);\n        } catch (error) {\n          if (isBenignStopError(error)) {\n            logger.debug(`[NativeSR] Stop already finalized (${reason})`);\n            return audioBackend.getUri(recording);\n          }\n          throw error;\n        } finally {\n          if (stopInFlightRef.current?.recording === recording) {\n            stopInFlightRef.current = null;\n          }\n        }\n      })();\n\n      stopInFlightRef.current = {\n        recording,\n        promise: stopPromise,\n      };\n      return stopPromise;\n    },\n    [],\n  );\n\n  /**\n   * Process recorded audio chunk and send to Groq (streaming)\n   */\n  const processAudioChunk = useCallback(async (fileUri: string) => {\n    let normalizedUri: string | undefined;\n\n    try {\n      logger.debug('[NativeSR] 🔍 Processing audio chunk:', fileUri);\n      normalizedUri = normalizeFileUri(fileUri);\n      logger.debug('[NativeSR] 📁 Normalized URI:', normalizedUri);\n      \n      // Read file\n      logger.debug('[NativeSR] 📖 Reading file info...');\n      const fileInfo = await FileSystem.getInfoAsync(normalizedUri);\n      logger.debug('[NativeSR] 📊 File info:', JSON.stringify(fileInfo));\n\n      if (!fileInfo.exists) {\n        logger.error('[NativeSR] ❌ Audio file missing:', normalizedUri);\n        return;\n      }\n\n      const fileSize =\n        'size' in fileInfo && typeof fileInfo.size === 'number'\n          ? fileInfo.size\n          : null;\n\n      const effectiveMinAudioSize = Math.max(minAudioSize, MIN_AUDIO_SIZE_FLOOR_BYTES);\n      if (fileSize !== null && fileSize < effectiveMinAudioSize) {\n        logger.warn(\n          `[NativeSR] ⚠️  Audio file too small (${fileSize} bytes, min: ${effectiveMinAudioSize})`\n        );\n        return;\n      }\n\n      logger.info(\n        `[NativeSR] 📤 Uploading ${fileSize ?? 'unknown'} bytes to Groq...`\n      );\n\n      const fileName = getFileNameFromUri(normalizedUri);\n      const mimeType = getMimeTypeFromName(fileName);\n\n      const controller = new AbortController();\n      streamAbortRef.current = controller;\n\n      const chunkText = await streamGroqTranscription({\n        apiKey: clientSecret,\n        audioBlob: {\n          uri: normalizedUri,\n          name: fileName,\n          type: mimeType,\n        },\n        mimeType,\n        language,\n        responseFormat: 'verbose_json',\n        stream,\n        endpoint: resolveGroqTranscriptionEndpoint(\n          groqApiBaseUrl,\n          groqTranscriptionEndpoint,\n        ),\n        signal: controller.signal,\n        onInterim: (text) => {\n          if (!text) return;\n          logger.debug(`[NativeSR] 📝 Interim chunk text (${text.length} chars)`);\n          currentChunkTranscriptRef.current = text;\n          \n          // Real-time callback like web version\n          const combined = mergeTranscriptParts(committedTranscriptRef.current, text);\n          if (combined !== lastInterimRef.current) {\n            lastInterimRef.current = combined;\n            speechStatusCallback(true, combined);\n          }\n        },\n      });\n\n      if (chunkText) {\n        logger.info(`[NativeSR] ✅ Chunk transcription complete (${chunkText.length} chars)`);\n        commitChunk(chunkText);\n        // Final update after chunk completes\n        const finalCombined = mergeTranscriptParts(committedTranscriptRef.current, '');\n        if (finalCombined !== lastInterimRef.current) {\n          lastInterimRef.current = finalCombined;\n          speechStatusCallback(true, finalCombined);\n        }\n      }\n    } catch (error) {\n      logger.error('[NativeSR] Groq transcription error:', error);\n      if (onError) {\n        onError(error as Error);\n      }\n    } finally {\n      try {\n        if (normalizedUri) {\n          await FileSystem.deleteAsync(normalizedUri, { idempotent: true });\n        }\n      } catch (error) {\n        logger.warn('[NativeSR] Failed to delete temp audio file:', error);\n      }\n    }\n  }, [\n    commitChunk,\n    clientSecret,\n    groqApiBaseUrl,\n    groqTranscriptionEndpoint,\n    stream,\n    language,\n    minAudioSize,\n    onError,\n  ]);\n\n  /**\n   * Start chunked recording loop for streaming transcription\n   */\n  const startChunkLoop = useCallback(async () => {\n    if (!audioBackend) return;\n    const controller = new AbortController();\n    chunkLoopAbortRef.current = controller;\n\n    logger.info(`[NativeSR] 🔄 Chunk loop started (${DEFAULT_CHUNK_DURATION_MS}ms chunks)`);\n    let chunkCount = 0;\n    let consecutiveStartFailures = 0;\n\n    while (!controller.signal.aborted) {\n      chunkCount++;\n      logger.debug(`[NativeSR] 📼 Recording chunk #${chunkCount}...`);\n      \n      let recording: any | null = null;\n      let started = false;\n\n      for (let attempt = 1; attempt <= MAX_START_ATTEMPTS; attempt++) {\n        if (controller.signal.aborted) {\n          break;\n        }\n\n        recording = audioBackend.createRecording();\n        activeRecordingRef.current = recording;\n\n        try {\n          await audioBackend.prepareToRecordAsync(recording);\n          await audioBackend.startAsync(recording);\n          logger.debug(`[NativeSR] 🎙️  Chunk #${chunkCount} recording...`);\n          started = true;\n          break;\n        } catch (error) {\n          logger.error(\n            `Failed to start chunk #${chunkCount} recording (attempt ${attempt}/${MAX_START_ATTEMPTS}):`,\n            error\n          );\n          activeRecordingRef.current = null;\n          if (attempt < MAX_START_ATTEMPTS) {\n            await sleep(START_RETRY_DELAY_MS);\n          }\n        }\n      }\n\n      if (!started || !recording) {\n        consecutiveStartFailures += 1;\n        logger.warn(\n          `[NativeSR] ⚠️  Chunk start failed (${consecutiveStartFailures}/${MAX_CONSECUTIVE_START_FAILURES}).`\n        );\n        if (consecutiveStartFailures >= MAX_CONSECUTIVE_START_FAILURES) {\n          logger.error('[NativeSR] ❌ Too many consecutive chunk start failures; ending loop.');\n          break;\n        }\n        await sleep(START_RETRY_DELAY_MS);\n        continue;\n      }\n\n      consecutiveStartFailures = 0;\n\n      await sleep(DEFAULT_CHUNK_DURATION_MS);\n\n      if (controller.signal.aborted) {\n        logger.info('[NativeSR] 🛑 Chunk loop aborted');\n        const stillActive = activeRecordingRef.current === recording;\n        if (stillActive) {\n          try {\n            const uri = await stopRecorderSafely(recording, `abort chunk #${chunkCount}`);\n            if (uri) {\n              logger.info(`[NativeSR] ✅ Final chunk URI (abort): ${uri.substring(0, 50)}...`);\n              const chunkPromise = processAudioChunk(uri)\n                .catch((error) => {\n                  logger.error('[NativeSR] Failed to process aborted chunk:', error);\n                })\n                .finally(() => {\n                  activeChunksRef.current.delete(chunkPromise);\n                });\n              activeChunksRef.current.add(chunkPromise);\n            } else {\n              logger.warn('[NativeSR] ⚠️  No URI for aborted chunk - skipping upload');\n            }\n          } catch (error) {\n            logger.warn('[NativeSR] Failed to stop chunk recording on abort:', error);\n          }\n        } else {\n          logger.debug('[NativeSR] Abort detected after external stop; skipping duplicate stop');\n        }\n        activeRecordingRef.current = null;\n        break;\n      }\n\n      try {\n        logger.debug(`[NativeSR] ⏹️  Stopping chunk #${chunkCount}...`);\n        const uri = await stopRecorderSafely(recording, `chunk #${chunkCount}`);\n        logger.debug(`[NativeSR] ✅ Chunk #${chunkCount} stopped`);\n        activeRecordingRef.current = null;\n\n        if (uri) {\n          logger.info(`[NativeSR] ✅ Chunk #${chunkCount} URI: ${uri.substring(0, 50)}...`);\n          // Process chunks truly in parallel - track active chunks\n          const chunkPromise = processAudioChunk(uri)\n            .catch((error) => {\n              logger.error(`[NativeSR] Failed to process chunk #${chunkCount}:`, error);\n            })\n            .finally(() => {\n              activeChunksRef.current.delete(chunkPromise);\n            });\n          activeChunksRef.current.add(chunkPromise);\n        } else {\n          logger.warn(`[NativeSR] ⚠️  No URI for chunk #${chunkCount} - skipping upload`);\n        }\n      } catch (error) {\n        logger.error(`[NativeSR] Failed to stop chunk #${chunkCount}:`, error);\n        activeRecordingRef.current = null;\n        continue; // Skip this chunk, try next one\n      }\n\n      if (!controller.signal.aborted) {\n        await sleep(POST_STOP_COOLDOWN_MS);\n      }\n    }\n    \n    logger.info(`[NativeSR] 🏁 Chunk loop ended (processed ${chunkCount} chunks)`);\n  }, [processAudioChunk, stopRecorderSafely]);\n\n  /**\n   * Start audio recording\n   */\n  const startRecording = useCallback(async () => {\n    try {\n      if (!audioBackend) {\n        throw new Error(missingAudioError);\n      }\n\n      logger.info(`[NativeSR] Start recording (backend=${audioBackend.kind})`);\n\n      // Request permissions\n      const hasPermission = await requestPermissions();\n      if (!hasPermission) {\n        logger.warn('[NativeSR] Permission denied');\n        speechStatusCallback(false, '');\n        return;\n      }\n\n      await audioBackend.setAudioModeAsync({\n        allowsRecording: true,\n        playsInSilentMode: true,\n        shouldPlayInBackground: false,\n        shouldRouteThroughEarpiece: false,\n        interruptionMode: 'duckOthers',\n      });\n\n      logger.debug('[NativeSR] Audio mode configured');\n      resetTranscriptState();\n      setIsRecording(true);\n      speechStatusCallback(true, '');\n\n      logger.info('[NativeSR] 🎤 Native recording started');\n      startChunkLoop();\n    } catch (error) {\n      logger.error('[NativeSR] Failed to start native recording:', error);\n      if (onError) {\n        onError(error as Error);\n      }\n      speechStatusCallback(false, '');\n    }\n  }, [speechStatusCallback, onError, resetTranscriptState, startChunkLoop]);\n\n  /**\n   * Stop audio recording\n   */\n  const stopRecording = useCallback(async () => {\n    if (!isRecording || !audioBackend) return;\n\n    try {\n      logger.info('[NativeSR] Stop recording requested');\n      if (chunkLoopAbortRef.current) {\n        chunkLoopAbortRef.current.abort();\n        chunkLoopAbortRef.current = null;\n      }\n\n      if (activeRecordingRef.current) {\n        const currentRecording = activeRecordingRef.current;\n        activeRecordingRef.current = null;\n        try {\n          logger.info('[NativeSR] ⏹️  Stopping final active recording...');\n          const uri = await stopRecorderSafely(currentRecording, 'explicit stop');\n          if (uri) {\n            logger.info('[NativeSR] ✅ Final recording URI:', uri);\n            const chunkPromise = processAudioChunk(uri)\n              .catch((error) => {\n                logger.error('[NativeSR] Failed to process final chunk:', error);\n              })\n              .finally(() => {\n                activeChunksRef.current.delete(chunkPromise);\n              });\n            activeChunksRef.current.add(chunkPromise);\n          } else {\n            logger.warn('[NativeSR] ⚠️  No URI from final recording');\n          }\n        } catch (error) {\n          logger.warn('[NativeSR] Failed to stop active recording:', error);\n        }\n      }\n\n      setIsRecording(false);\n\n      // Wait for all active chunks to complete (truly parallel)\n      try {\n        logger.info(`[NativeSR] ⏳ Waiting for ${activeChunksRef.current.size} active chunks to complete...`);\n        await Promise.all(Array.from(activeChunksRef.current));\n        logger.info('[NativeSR] ✅ All chunks processed');\n      } catch (error) {\n        logger.warn('[NativeSR] Some chunks failed:', error);\n      }\n\n      const finalText =\n        committedTranscriptRef.current ||\n        currentChunkTranscriptRef.current;\n\n      if (\n        speechTranslationCallback &&\n        finalText &&\n        language &&\n        !language.startsWith('en')\n      ) {\n        try {\n          const translated = await translateGroqText({\n            apiKey: clientSecret,\n            text: finalText,\n            language,\n            endpoint: resolveGroqChatEndpoint(groqApiBaseUrl),\n          });\n          if (translated) {\n            speechTranslationCallback(translated);\n          }\n        } catch (error) {\n          logger.warn('[NativeSR] Groq translation failed:', error);\n        }\n      }\n\n      logger.info(`[NativeSR] Final text length: ${finalText.length}`);\n      speechStatusCallback(false, '');\n      if (finalText) {\n        speechResultCallback(finalText);\n      }\n\n      resetTranscriptState();\n    } catch (error) {\n      logger.error('[NativeSR] Failed to stop native recording:', error);\n      if (onError) {\n        onError(error as Error);\n      }\n      speechStatusCallback(false, '');\n    }\n  }, [\n    isRecording,\n    clientSecret,\n    groqApiBaseUrl,\n    language,\n    onError,\n    processAudioChunk,\n    resetTranscriptState,\n    speechResultCallback,\n    speechStatusCallback,\n    speechTranslationCallback,\n    stopRecorderSafely,\n  ]);\n\n  /**\n   * Handle shouldListen prop changes\n   */\n  useEffect(() => {\n    logger.debug(`[NativeSR] shouldListen=${shouldListen} isRecording=${isRecording}`);\n    if (shouldListen && !isRecording) {\n      startRecording();\n    } else if (!shouldListen && isRecording) {\n      stopRecording();\n    }\n  }, [shouldListen, isRecording, startRecording, stopRecording]);\n\n  /**\n   * Cleanup on unmount\n   */\n  useEffect(() => {\n    return () => {\n      if (chunkLoopAbortRef.current) {\n        logger.info('[NativeSR] Cleanup: aborting chunk loop');\n        chunkLoopAbortRef.current.abort();\n      }\n      if (streamAbortRef.current) {\n        logger.info('[NativeSR] Cleanup: aborting stream');\n        streamAbortRef.current.abort();\n      }\n      if (activeRecordingRef.current && audioBackend) {\n        logger.info('[NativeSR] Cleanup: stopping active recording');\n        stopRecorderSafely(activeRecordingRef.current, 'cleanup').catch(() => undefined);\n      }\n    };\n  }, [stopRecorderSafely]);\n\n  return <View />;\n};\n\nfunction sleep(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction isBenignStopError(error: unknown): boolean {\n  const message =\n    error instanceof Error ? error.message : typeof error === 'string' ? error : '';\n  return /stop failed|already|not recording/i.test(message);\n}\n\n/**\n * Convert base64 string to Blob\n */\nfunction getFileNameFromUri(uri: string): string {\n  const cleanUri = uri.split('?')[0];\n  const lastSlash = cleanUri.lastIndexOf('/');\n  const fileName = lastSlash >= 0 ? cleanUri.slice(lastSlash + 1) : cleanUri;\n  if (fileName && fileName.includes('.')) {\n    return fileName;\n  }\n  return `audio-${Date.now()}.m4a`;\n}\n\nfunction getMimeTypeFromName(name: string): string {\n  const ext = name.split('.').pop()?.toLowerCase() || '';\n  switch (ext) {\n    case 'm4a':\n      return 'audio/m4a';\n    case 'aac':\n      return 'audio/aac';\n    case 'mp3':\n      return 'audio/mpeg';\n    case 'mp4':\n      return 'audio/mp4';\n    case 'wav':\n      return 'audio/wav';\n    case 'webm':\n      return 'audio/webm';\n    case 'ogg':\n      return 'audio/ogg';\n    default:\n      return 'audio/m4a';\n  }\n}\n\nfunction resolveGroqTranscriptionEndpoint(\n  baseUrl?: string,\n  overrideEndpoint?: string,\n): string | undefined {\n  if (overrideEndpoint) return overrideEndpoint;\n  if (!baseUrl) return undefined;\n  const trimmed = baseUrl.replace(/\\/+$/, '');\n  if (trimmed.endsWith('/openai/v1')) {\n    return `${trimmed}/audio/transcriptions`;\n  }\n  return `${trimmed}/openai/v1/audio/transcriptions`;\n}\n\nfunction resolveGroqChatEndpoint(baseUrl?: string): string | undefined {\n  if (!baseUrl) return undefined;\n  const trimmed = baseUrl.replace(/\\/+$/, '');\n  if (trimmed.endsWith('/openai/v1')) {\n    return `${trimmed}/chat/completions`;\n  }\n  return `${trimmed}/openai/v1/chat/completions`;\n}\n\nfunction normalizeFileUri(uri: string): string {\n  if (!uri) return uri;\n  if (uri.startsWith('file://') || uri.startsWith('content://')) {\n    return uri;\n  }\n  if (uri.startsWith('/')) {\n    return `file://${uri}`;\n  }\n  return uri;\n}\n\n/**\n * Check if native speech recognition is available\n */\nexport function isNativeSpeechAvailable(): boolean {\n  return (Platform.OS === 'ios' || Platform.OS === 'android') && !!audioBackend;\n}\n\n/**\n * Get native speech capabilities\n */\nexport function getNativeSpeechCapabilities() {\n  return {\n    available: isNativeSpeechAvailable(),\n    platform: Platform.OS,\n    supportsVAD: true,\n    supportsAudioLevels: true,\n    requiresExpoAudio: true,\n    backend: audioBackend?.kind ?? 'none',\n  };\n}\n"],"mappings":"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","ignoreList":[]}