react-native-sherpa-onnx 0.3.2 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-sherpa-onnx",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Offline Speech-to-text, text-to-speech, speaker diarization, speech enhancement, source separation, and VAD with sherpa-onnx for React NativeSpeech-to-Text with sherpa-onnx for React Native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -78,6 +78,8 @@
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__",
+    "!test",
+    "!test/**",
     "!**/.*",
     "!./third_party/sherpa-onnx",
     "!./third_party/sherpa-onnx/**",
@@ -154,6 +156,9 @@
     "turbo": "^2.5.6",
     "typescript": "^5.9.2"
   },
+  "dependencies": {
+    "buffer": "^6.0.3"
+  },
   "peerDependencies": {
     "@dr.pogodin/react-native-fs": "*",
     "react": "*",

package/scripts/check-model-csvs.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# Compare GitHub release assets (asr-models, tts-models) with local CSV fixtures.
+# If any asset exists on GitHub but is not listed in the corresponding CSV,
+# print a warning (non-fatal) with the list and a hint to run the collect workflows.
+# Exit code is always 0 so this can be used as an informational step.
+
+set -e
+
+REPO="${SHERPA_ONNX_REPO:-k2-fsa/sherpa-onnx}"
+ASR_CSV="${ASR_CSV:-test/fixtures/asr-models-expected.csv}"
+TTS_CSV="${TTS_CSV:-test/fixtures/tts-models-expected.csv}"
+
+if [ ! -f "$ASR_CSV" ]; then
+  echo "::warning::Missing $ASR_CSV (run from repo root or set ASR_CSV)"
+  exit 0
+fi
+if [ ! -f "$TTS_CSV" ]; then
+  echo "::warning::Missing $TTS_CSV (run from repo root or set TTS_CSV)"
+  exit 0
+fi
+
+# Fetch ASR release assets (.tar.bz2, .onnx)
+ASR_ASSETS=""
+ASR_RESP="${ASR_RESP:-$(curl -sL "https://api.github.com/repos/${REPO}/releases/tags/asr-models")}"
+if echo "$ASR_RESP" | jq -e '.assets' >/dev/null 2>&1; then
+  ASR_ASSETS=$(echo "$ASR_RESP" | jq -r '.assets[] | select(.name | endswith(".tar.bz2") or endswith(".onnx")) | .name')
+else
+  echo "::warning::Could not fetch asr-models release or it has no assets"
+fi
+
+# Fetch TTS release assets
+TTS_ASSETS=""
+TTS_RESP="${TTS_RESP:-$(curl -sL "https://api.github.com/repos/${REPO}/releases/tags/tts-models")}"
+if echo "$TTS_RESP" | jq -e '.assets' >/dev/null 2>&1; then
+  TTS_ASSETS=$(echo "$TTS_RESP" | jq -r '.assets[] | select(.name | endswith(".tar.bz2") or endswith(".onnx")) | .name')
+else
+  echo "::warning::Could not fetch tts-models release or it has no assets"
+fi
+
+# First column of CSV (asset_name); strip optional quotes and whitespace; skip header
+csv_asset_names() { awk -F',' '{ gsub(/^ *"|" *$/, "", $1); gsub(/^ | $/, "", $1); if (NR>1 && $1 != "") print $1 }' "$1"; }
+
+ASR_CSV_NAMES=$(csv_asset_names "$ASR_CSV")
+TTS_CSV_NAMES=$(csv_asset_names "$TTS_CSV")
+
+ASR_MISSING=""
+while IFS= read -r asset; do
+  [ -z "$asset" ] && continue
+  if ! echo "$ASR_CSV_NAMES" | grep -qFx "$asset"; then
+    ASR_MISSING="${ASR_MISSING}  - ${asset}\n"
+  fi
+done <<< "$ASR_ASSETS"
+
+TTS_MISSING=""
+while IFS= read -r asset; do
+  [ -z "$asset" ] && continue
+  if ! echo "$TTS_CSV_NAMES" | grep -qFx "$asset"; then
+    TTS_MISSING="${TTS_MISSING}  - ${asset}\n"
+  fi
+done <<< "$TTS_ASSETS"
+
+if [ -n "$ASR_MISSING" ] || [ -n "$TTS_MISSING" ]; then
+  echo "::warning::New assets are available on GitHub but not yet listed in the expected CSV files."
+  [ -n "$ASR_MISSING" ] && echo -e "ASR (asr-models) assets missing from $ASR_CSV:\n$ASR_MISSING"
+  [ -n "$TTS_MISSING" ] && echo -e "TTS (tts-models) assets missing from $TTS_CSV:\n$TTS_MISSING"
+  echo "Please run the collect workflows to update fixtures:"
+  echo "  - Testdata - Collect ASR model structures (workflow_dispatch)"
+  echo "  - Testdata - Collect TTS model structures (workflow_dispatch)"
+  exit 0
+fi
+
+echo "All GitHub release assets are listed in the expected CSV files."

package/scripts/setup-ios-framework.sh

@@ -73,6 +73,17 @@ fi
 # Create frameworks directory if it doesn't exist
 mkdir -p "$FRAMEWORKS_DIR"
 
+# Read desired version early so we can skip download only when installed version matches (avoids stale framework after IOS_RELEASE_TAG update).
+if [ -z "$DESIRED_VERSION" ] && [ "$FORCE_DOWNLOAD" != true ]; then
+  IOS_TAG_FILE="$PROJECT_ROOT/third_party/sherpa-onnx-prebuilt/IOS_RELEASE_TAG"
+  if [ -f "$IOS_TAG_FILE" ]; then
+    TAG=$(grep -v '^#' "$IOS_TAG_FILE" | grep -v '^[[:space:]]*$' | head -1 | tr -d '\r\n')
+    if [ -n "$TAG" ] && [ "${TAG#framework-v}" != "$TAG" ]; then
+      DESIRED_VERSION="${TAG#framework-v}"
+    fi
+  fi
+fi
+
 # Helper: check if a framework path is valid for building (has library + required headers for compiler)
 framework_valid() {
   local fw_root="$1"
@@ -81,17 +92,47 @@ framework_valid() {
   return 0
 }
 
-# When run as Xcode build phase (prepare_command): if framework is already present and valid, exit successfully.
-# Avoids network/TAG-file dependency during build and prevents "PhaseScriptExecution failed" when nothing is needed.
-# We require both the library and the Headers (sherpa-onnx/c-api/cxx-api.h) so an incomplete framework triggers a re-download.
+# Helper: get installed framework version (from .framework-version or xcframework VERSION.txt)
+get_installed_version() {
+  if [ -f "$VERSION_FILE" ]; then
+    cat "$VERSION_FILE" 2>/dev/null | tr -d '\r\n'
+    return 0
+  fi
+  for f in "sherpa_onnx.xcframework" "sherpa-onnx.xcframework"; do
+    if [ -f "$FRAMEWORKS_DIR/$f/VERSION.txt" ]; then
+      grep -Eo '([0-9]+\.)+[0-9]+' "$FRAMEWORKS_DIR/$f/VERSION.txt" | head -n1 | tr -d '\r\n'
+      return 0
+    fi
+  done
+  echo ""
+}
+
+# When run as Xcode build phase (prepare_command): if framework is already present, valid, AND matches IOS_RELEASE_TAG, exit successfully.
+# Otherwise we re-download so that updating IOS_RELEASE_TAG (e.g. to 1.12.28) triggers an update from an older installed version (e.g. 1.12.24).
 if [ "$FORCE_DOWNLOAD" != true ]; then
   if [ -d "$FRAMEWORKS_DIR/sherpa_onnx.xcframework" ] && framework_valid "$FRAMEWORKS_DIR/sherpa_onnx.xcframework"; then
-    echo "[SherpaOnnx] Framework already present at $FRAMEWORKS_DIR/sherpa_onnx.xcframework, skipping download." >&2
-    exit 0
+    if [ ! -f "$VERSION_FILE" ] && [ -f "$FRAMEWORKS_DIR/sherpa_onnx.xcframework/VERSION.txt" ]; then
+      ver=$(grep -Eo '([0-9]+\.)+[0-9]+' "$FRAMEWORKS_DIR/sherpa_onnx.xcframework/VERSION.txt" | head -n1 || true)
+      [ -n "$ver" ] && echo "$ver" > "$VERSION_FILE" 2>/dev/null || true
+    fi
+    installed=$(get_installed_version)
+    if [ -n "$DESIRED_VERSION" ] && [ -n "$installed" ] && [ "$installed" = "$DESIRED_VERSION" ]; then
+      echo "[SherpaOnnx] Framework already present at $FRAMEWORKS_DIR/sherpa_onnx.xcframework (v$installed), skipping download." >&2
+      exit 0
+    fi
+    [ "$INTERACTIVE" = true ] && echo -e "${YELLOW}Installed framework v${installed} does not match IOS_RELEASE_TAG ($DESIRED_VERSION), will re-download.${NC}" >&2
   fi
   if [ -d "$FRAMEWORKS_DIR/sherpa-onnx.xcframework" ] && framework_valid "$FRAMEWORKS_DIR/sherpa-onnx.xcframework"; then
-    echo "[SherpaOnnx] Framework already present at $FRAMEWORKS_DIR/sherpa-onnx.xcframework, skipping download." >&2
-    exit 0
+    if [ ! -f "$VERSION_FILE" ] && [ -f "$FRAMEWORKS_DIR/sherpa-onnx.xcframework/VERSION.txt" ]; then
+      ver=$(grep -Eo '([0-9]+\.)+[0-9]+' "$FRAMEWORKS_DIR/sherpa-onnx.xcframework/VERSION.txt" | head -n1 || true)
+      [ -n "$ver" ] && echo "$ver" > "$VERSION_FILE" 2>/dev/null || true
+    fi
+    installed=$(get_installed_version)
+    if [ -n "$DESIRED_VERSION" ] && [ -n "$installed" ] && [ "$installed" = "$DESIRED_VERSION" ]; then
+      echo "[SherpaOnnx] Framework already present at $FRAMEWORKS_DIR/sherpa-onnx.xcframework (v$installed), skipping download." >&2
+      exit 0
+    fi
+    [ "$INTERACTIVE" = true ] && echo -e "${YELLOW}Installed framework v${installed} does not match IOS_RELEASE_TAG ($DESIRED_VERSION), will re-download.${NC}" >&2
   fi
 fi
 
@@ -154,47 +195,6 @@ compare_versions() {
   echo "0"  # v1 == v2
 }
 
-# Function to get latest framework version from GitHub
-get_latest_framework_version() {
-  echo -e "${YELLOW}Fetching latest framework release from GitHub...${NC}" >&2
-
-  local releases_json=$(curl -s "${AUTH_ARGS[@]}" -H "Accept: application/vnd.github+json" "https://api.github.com/repos/XDcobra/react-native-sherpa-onnx/releases" 2>/dev/null || echo "")
-
-  if [ -z "$releases_json" ]; then
-    echo -e "${RED}Error: Could not fetch releases from GitHub API${NC}" >&2
-    return 1
-  fi
-
-  # Avoid jq errors on rate-limit HTML or plain-text responses
-  if ! echo "$releases_json" | grep -q '"tag_name"'; then
-    echo -e "${RED}Error: GitHub API response did not contain release data (possible rate limit).${NC}" >&2
-    echo "Response (truncated):" >&2
-    echo "$releases_json" | head -5 >&2
-    return 1
-  fi
-
-  local version=""
-
-  if command -v jq &> /dev/null; then
-    if echo "$releases_json" | jq -e . > /dev/null 2>&1; then
-      version=$(echo "$releases_json" | jq -r '.[] | select(.tag_name | startswith("framework-v")) | .tag_name' | head -1 | sed 's/framework-v//')
-    else
-      echo -e "${RED}Error: GitHub releases response is not valid JSON${NC}" >&2
-      echo "$releases_json" | head -5 >&2
-      return 1
-    fi
-  else
-    version=$(echo "$releases_json" | grep -o '"tag_name": "framework-v[0-9.]*' | head -1 | sed 's/.*framework-v//')
-  fi
-
-  if [ -z "$version" ]; then
-    echo -e "${RED}Error: No framework releases found with tag format 'framework-vX.Y.Z'${NC}" >&2
-    return 1
-  fi
-
-  echo "$version"
-}
-
 # Function to get local framework version
 get_local_framework_version() {
   # Prefer explicit version file written by this script

package/src/NativeSherpaOnnx.ts

@@ -21,7 +21,7 @@ export interface Spec extends TurboModule {
    * @param instanceId - Unique ID for this engine instance (from createSTT)
    * @param modelDir - Absolute path to model directory
    * @param preferInt8 - Optional: true = prefer int8 models, false = prefer regular models, undefined = try int8 first (default)
-   * @param modelType - Optional: explicit model type ('transducer', 'nemo_transducer', 'paraformer', 'nemo_ctc', 'wenet_ctc', 'sense_voice', 'zipformer_ctc', 'whisper', 'funasr_nano', 'fire_red_asr', 'moonshine', 'dolphin', 'canary', 'omnilingual', 'medasr', 'telespeech_ctc', 'auto'), undefined = auto (default)
+   * @param modelType - Optional: explicit model type ('transducer', 'nemo_transducer', 'paraformer', 'nemo_ctc', 'wenet_ctc', 'sense_voice', 'zipformer_ctc', 'whisper', 'funasr_nano', 'fire_red_asr', 'moonshine', 'moonshine_v2', 'dolphin', 'canary', 'omnilingual', 'medasr', 'telespeech_ctc', 'auto'), undefined = auto (default)
    * @param debug - Optional: enable debug logging in native layer and sherpa-onnx (default: false)
    * @param hotwordsFile - Optional: path to hotwords file (OfflineRecognizerConfig)
    * @param hotwordsScore - Optional: hotwords score (default in Kotlin 1.5)
@@ -65,7 +65,7 @@ export interface Spec extends TurboModule {
    * @param modelDir - Absolute path to model directory (use resolveModelPath first for asset/file paths)
    * @param preferInt8 - Optional: true = prefer int8, false = prefer regular, undefined = try int8 first
    * @param modelType - Optional: explicit type or 'auto' (default)
-   * @returns Object with success, detectedModels (array of { type, modelDir }), and modelType (primary detected type)
+   * @returns Object with success, detectedModels (array of { type, modelDir }), modelType (primary detected type), and optionally isHardwareSpecificUnsupported (true when the model is for unsupported hardware e.g. RK35xx, Ascend)
    */
   detectSttModel(
     modelDir: string,
@@ -73,6 +73,8 @@ export interface Spec extends TurboModule {
     modelType?: string
   ): Promise<{
     success: boolean;
+    /** True when detection failed because the model targets unsupported hardware (RK35xx, Ascend, CANN). Use to show a specific message or block init. */
+    isHardwareSpecificUnsupported?: boolean;
     detectedModels: Array<{ type: string; modelDir: string }>;
     modelType?: string;
   }>;
@@ -211,6 +213,20 @@ export interface Spec extends TurboModule {
     isEndpoint: boolean;
   }>;
 
+  /**
+   * Start native PCM live capture. Microphone audio is captured and resampled to the requested
+   * sampleRate; chunks are emitted via the "pcmLiveStreamData" event (base64 Int16 PCM).
+   * App must have RECORD_AUDIO (Android) and NSMicrophoneUsageDescription (iOS) and grant permission before calling.
+   */
+  startPcmLiveStream(options: {
+    sampleRate: number;
+    channelCount?: number;
+    bufferSizeFrames?: number;
+  }): Promise<void>;
+
+  /** Stop native PCM live capture. */
+  stopPcmLiveStream(): Promise<void>;
+
   // ==================== TTS Methods ====================
 
   /**

package/src/audio/index.ts

@@ -1,5 +1,86 @@
+import { Buffer } from 'buffer';
+import { DeviceEventEmitter } from 'react-native';
 import SherpaOnnx from '../NativeSherpaOnnx';
 
+/**
+ * Decode base64-encoded Int16 PCM to float array in [-1, 1].
+ * Uses a preallocated Float32Array to avoid GC pressure on the live-mic hot path.
+ */
+function base64PcmToFloatArray(base64: string): Float32Array {
+  const bytes = Buffer.from(base64, 'base64');
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const len = bytes.byteLength / 2;
+  const out = new Float32Array(len);
+  for (let i = 0; i < len; i++) {
+    out[i] = view.getInt16(i * 2, true) / 32768;
+  }
+  return out;
+}
+
+export type PcmLiveStreamOptions = {
+  sampleRate?: number;
+  channelCount?: number;
+  bufferSizeFrames?: number;
+};
+
+export type PcmLiveStreamHandle = {
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  onData: (
+    callback: (samples: Float32Array, sampleRate: number) => void
+  ) => () => void;
+  onError: (callback: (message: string) => void) => () => void;
+};
+
+/**
+ * Create a PCM live stream from the device microphone. Native capture and resampling ensure
+ * PCM is always delivered at the requested sampleRate (e.g. 16000 for STT). The app must have
+ * RECORD_AUDIO (Android) and NSMicrophoneUsageDescription (iOS) and grant permission before start().
+ */
+export function createPcmLiveStream(
+  options?: PcmLiveStreamOptions
+): PcmLiveStreamHandle {
+  const sampleRate = options?.sampleRate ?? 16000;
+  const channelCount = options?.channelCount ?? 1;
+  const bufferSizeFrames = options?.bufferSizeFrames ?? 0;
+
+  return {
+    start: () =>
+      SherpaOnnx.startPcmLiveStream({
+        sampleRate,
+        channelCount,
+        bufferSizeFrames,
+      }),
+
+    stop: () => SherpaOnnx.stopPcmLiveStream(),
+
+    onData: (callback: (samples: Float32Array, sampleRate: number) => void) => {
+      const sub = DeviceEventEmitter.addListener(
+        'pcmLiveStreamData',
+        (event: { base64Pcm?: string; sampleRate?: number }) => {
+          const base64 = event?.base64Pcm ?? '';
+          const sr = event?.sampleRate ?? sampleRate;
+          if (base64) {
+            const samples = base64PcmToFloatArray(base64);
+            callback(samples, sr);
+          }
+        }
+      );
+      return () => sub.remove();
+    },
+
+    onError: (callback: (message: string) => void) => {
+      const sub = DeviceEventEmitter.addListener(
+        'pcmLiveStreamError',
+        (event: { message?: string }) => {
+          callback(event?.message ?? 'Unknown error');
+        }
+      );
+      return () => sub.remove();
+    },
+  };
+}
+
 /**
  * Convert any supported audio file to a requested format (e.g. "mp3", "flac", "wav").
  * On Android this requires FFmpeg prebuilts. WAV output is always 16 kHz mono (sherpa-onnx).

package/src/stt/streaming.ts

@@ -317,11 +317,11 @@ export async function createStreamingSTT(
         },
 
         async processAudioChunk(
-          samples: number[],
+          samples: number[] | Float32Array,
           sampleRate: number
         ): Promise<{ result: StreamingSttResult; isEndpoint: boolean }> {
           streamGuard();
-          let toSend: number[] = samples;
+          let toSend: number[] | Float32Array = samples;
           if (enableInputNormalization && samples.length > 0) {
             let maxAbs = 1e-10;
             for (let i = 0; i < samples.length; i++) {
@@ -329,15 +329,20 @@ export async function createStreamingSTT(
               if (abs > maxAbs) maxAbs = abs;
             }
             const scale = maxAbs < 0.01 ? 80 : Math.min(80, 0.8 / maxAbs);
-            toSend = new Array(samples.length);
+            const normalized = new Float32Array(samples.length);
             for (let i = 0; i < samples.length; i++) {
               const v = samples[i]! * scale;
-              toSend[i] = v < -1 ? -1 : v > 1 ? 1 : v;
+              normalized[i] = v < -1 ? -1 : v > 1 ? 1 : v;
             }
+            toSend = normalized;
           }
+          // Bridge expects a plain array; Float32Array may not serialize as ReadableArray on all platforms.
+          const samplesArray = Array.isArray(toSend)
+            ? toSend
+            : Array.from(toSend);
           const raw = await SherpaOnnx.processSttAudioChunk(
             streamId,
-            toSend,
+            samplesArray,
             sampleRate
           );
           return {

package/src/stt/streamingTypes.ts

@@ -132,7 +132,7 @@ export interface SttStream {
    * Reduces bridge round-trips from 5 to 1 per chunk.
    */
   processAudioChunk(
-    samples: number[],
+    samples: number[] | Float32Array,
     sampleRate: number
   ): Promise<{ result: StreamingSttResult; isEndpoint: boolean }>;
 }

package/third_party/sherpa-onnx-prebuilt/ANDROID_RELEASE_TAG

@@ -1 +1 @@
-sherpa-onnx-android-v1.12.24
+sherpa-onnx-android-v1.12.28

package/third_party/sherpa-onnx-prebuilt/IOS_RELEASE_TAG

@@ -1 +1 @@
-framework-v1.12.24
+framework-v1.12.28