whisper.rn 0.4.0 → 0.4.2

package/android/src/newarch/java/com/rnwhisper/RNWhisperModule.java

@@ -77,6 +77,32 @@ public class RNWhisperModule extends NativeRNWhisperSpec {
     rnwhisper.releaseAllContexts(promise);
   }
 
+  // VAD methods
+  @ReactMethod
+  public void initVadContext(final ReadableMap options, final Promise promise) {
+    rnwhisper.initVadContext(options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeech(double id, String audioDataBase64, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeech(id, audioDataBase64, options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeechFile(double id, String filePath, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeechFile(id, filePath, options, promise);
+  }
+
+  @ReactMethod
+  public void releaseVadContext(double id, Promise promise) {
+    rnwhisper.releaseVadContext(id, promise);
+  }
+
+  @ReactMethod
+  public void releaseAllVadContexts(Promise promise) {
+    rnwhisper.releaseAllVadContexts(promise);
+  }
+
   /*
    * iOS Specific methods, left here for make the turbo module happy:
    */

package/android/src/oldarch/java/com/rnwhisper/RNWhisperModule.java

@@ -76,4 +76,30 @@ public class RNWhisperModule extends ReactContextBaseJavaModule {
   public void releaseAllContexts(Promise promise) {
     rnwhisper.releaseAllContexts(promise);
   }
+
+  // VAD methods
+  @ReactMethod
+  public void initVadContext(final ReadableMap options, final Promise promise) {
+    rnwhisper.initVadContext(options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeech(double id, String audioDataBase64, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeech(id, audioDataBase64, options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeechFile(double id, String filePath, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeechFile(id, filePath, options, promise);
+  }
+
+  @ReactMethod
+  public void releaseVadContext(double id, Promise promise) {
+    rnwhisper.releaseVadContext(id, promise);
+  }
+
+  @ReactMethod
+  public void releaseAllVadContexts(Promise promise) {
+    rnwhisper.releaseAllVadContexts(promise);
+  }
 }

package/ios/RNWhisper.mm

@@ -1,5 +1,6 @@
 #import "RNWhisper.h"
 #import "RNWhisperContext.h"
+#import "RNWhisperVadContext.h"
 #import "RNWhisperDownloader.h"
 #import "RNWhisperAudioUtils.h"
 #import "RNWhisperAudioSessionUtils.h"
@@ -13,6 +14,7 @@
 @implementation RNWhisper
 
 NSMutableDictionary *contexts;
+NSMutableDictionary *vadContexts;
 
 RCT_EXPORT_MODULE()
 
@@ -366,6 +368,15 @@ RCT_REMAP_METHOD(releaseAllContexts,
         [context invalidate];
     }
 
+    if (vadContexts != nil) {
+        for (NSNumber *contextId in vadContexts) {
+            RNWhisperVadContext *vadContext = vadContexts[contextId];
+            [vadContext invalidate];
+        }
+        [vadContexts removeAllObjects];
+        vadContexts = nil;
+    }
+
     rnwhisper::job_abort_all(); // graceful abort
 
     [contexts removeAllObjects];
@@ -437,6 +448,142 @@ RCT_REMAP_METHOD(setAudioSessionActive,
     resolve(nil);
 }
 
+RCT_REMAP_METHOD(initVadContext,
+                 withVadOptions:(NSDictionary *)vadOptions
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (vadContexts == nil) {
+        vadContexts = [[NSMutableDictionary alloc] init];
+    }
+
+    NSString *modelPath = [vadOptions objectForKey:@"filePath"];
+    BOOL isBundleAsset = [[vadOptions objectForKey:@"isBundleAsset"] boolValue];
+    BOOL useGpu = [[vadOptions objectForKey:@"useGpu"] boolValue];
+    NSNumber *nThreads = [vadOptions objectForKey:@"nThreads"];
+
+    NSString *path = modelPath;
+    if ([path hasPrefix:@"http://"] || [path hasPrefix:@"https://"]) {
+        path = [RNWhisperDownloader downloadFile:path toFile:nil];
+    }
+    if (isBundleAsset) {
+        path = [[NSBundle mainBundle] pathForResource:modelPath ofType:nil];
+    }
+
+    int contextId = arc4random_uniform(1000000);
+
+    RNWhisperVadContext *vadContext = [RNWhisperVadContext
+        initWithModelPath:path
+        contextId:contextId
+        noMetal:!useGpu
+        nThreads:nThreads
+    ];
+    if ([vadContext getVadContext] == NULL) {
+        reject(@"whisper_vad_error", @"Failed to load the VAD model", nil);
+        return;
+    }
+
+    [vadContexts setObject:vadContext forKey:[NSNumber numberWithInt:contextId]];
+
+    resolve(@{
+        @"contextId": @(contextId),
+        @"gpu": @([vadContext isMetalEnabled]),
+        @"reasonNoGPU": [vadContext reasonNoMetal],
+    });
+}
+
+RCT_REMAP_METHOD(vadDetectSpeech,
+                 withContextId:(int)contextId
+                 withAudioData:(NSString *)audioDataBase64
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RNWhisperVadContext *vadContext = vadContexts[[NSNumber numberWithInt:contextId]];
+
+    if (vadContext == nil) {
+        reject(@"whisper_vad_error", @"VAD context not found", nil);
+        return;
+    }
+
+    // Decode base64 audio data
+    NSData *pcmData = [[NSData alloc] initWithBase64EncodedString:audioDataBase64 options:0];
+    if (pcmData == nil) {
+        reject(@"whisper_vad_error", @"Invalid audio data", nil);
+        return;
+    }
+
+    int count = 0;
+    float *data = [RNWhisperAudioUtils decodeWaveData:pcmData count:&count cutHeader:NO];
+
+    NSArray *segments = [vadContext detectSpeech:data samplesCount:count options:options];
+    resolve(segments);
+}
+
+RCT_REMAP_METHOD(vadDetectSpeechFile,
+                 withVadContextId:(int)contextId
+                 withFilePath:(NSString *)filePath
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RNWhisperVadContext *vadContext = vadContexts[[NSNumber numberWithInt:contextId]];
+
+    if (vadContext == nil) {
+        reject(@"whisper_vad_error", @"VAD context not found", nil);
+        return;
+    }
+
+    // Handle different input types like transcribeFile does
+    float *data = nil;
+    int count = 0;
+    if ([filePath hasPrefix:@"http://"] || [filePath hasPrefix:@"https://"]) {
+        NSString *path = [RNWhisperDownloader downloadFile:filePath toFile:nil];
+        data = [RNWhisperAudioUtils decodeWaveFile:path count:&count];
+    } else if ([filePath hasPrefix:@"data:audio/wav;base64,"]) {
+        NSData *waveData = [[NSData alloc] initWithBase64EncodedString:[filePath substringFromIndex:22] options:0];
+        data = [RNWhisperAudioUtils decodeWaveData:waveData count:&count cutHeader:YES];
+    } else {
+        data = [RNWhisperAudioUtils decodeWaveFile:filePath count:&count];
+    }
+
+    if (data == nil) {
+        reject(@"whisper_vad_error", @"Failed to load or decode audio file", nil);
+        return;
+    }
+
+    NSArray *segments = [vadContext detectSpeech:data samplesCount:count options:options];
+    resolve(segments);
+}
+
+RCT_REMAP_METHOD(releaseVadContext,
+                 withVadContextId:(int)contextId
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RNWhisperVadContext *vadContext = vadContexts[[NSNumber numberWithInt:contextId]];
+    if (vadContext == nil) {
+        reject(@"whisper_vad_error", @"VAD context not found", nil);
+        return;
+    }
+    [vadContext invalidate];
+    [vadContexts removeObjectForKey:[NSNumber numberWithInt:contextId]];
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(releaseAllVadContexts:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (vadContexts != nil) {
+        for (NSNumber *contextId in vadContexts) {
+            RNWhisperVadContext *vadContext = vadContexts[contextId];
+            [vadContext invalidate];
+        }
+        [vadContexts removeAllObjects];
+    }
+    resolve(nil);
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params

package/ios/RNWhisperContext.mm

@@ -36,36 +36,30 @@
         NSLog(@"[RNWhisper] ggml-metal is not enabled in this build, ignoring use_gpu option");
         cparams.use_gpu = false;
     }
+    reasonNoMetal = @"Metal is not enabled in this build";
 #endif
 
 #ifdef WSP_GGML_USE_METAL
     if (cparams.use_gpu) {
-#if TARGET_OS_SIMULATOR
-        NSLog(@"[RNWhisper] ggml-metal is not available in simulator, ignoring use_gpu option: %@", reasonNoMetal);
-        cparams.use_gpu = false;
-#else // TARGET_OS_SIMULATOR
-        // Check ggml-metal availability
-        NSError * error = nil;
         id<MTLDevice> device = MTLCreateSystemDefaultDevice();
-        id<MTLLibrary> library = [device
-            newLibraryWithSource:@"#include <metal_stdlib>\n"
-                                    "using namespace metal;"
-                                    "kernel void test() { simd_sum(0); }"
-            options:nil
-            error:&error
-        ];
-        if (error) {
-            reasonNoMetal = [error localizedDescription];
-        } else {
-            id<MTLFunction> kernel = [library newFunctionWithName:@"test"];
-            id<MTLComputePipelineState> pipeline = [device newComputePipelineStateWithFunction:kernel error:&error];
-            if (pipeline == nil) {
-                reasonNoMetal = [error localizedDescription];
-                NSLog(@"[RNWhisper] ggml-metal is not available, ignoring use_gpu option: %@", reasonNoMetal);
-                cparams.use_gpu = false;
-            }
+
+        // Check ggml-metal availability
+        BOOL supportsGgmlMetal = [device supportsFamily:MTLGPUFamilyApple7];
+        if (@available(iOS 16.0, tvOS 16.0, *)) {
+            supportsGgmlMetal = supportsGgmlMetal && [device supportsFamily:MTLGPUFamilyMetal3];
         }
-#endif // TARGET_OS_SIMULATOR
+        if (!supportsGgmlMetal) {
+            cparams.use_gpu = false;
+            reasonNoMetal = @"Metal is not supported in this device";
+        }
+
+#if TARGET_OS_SIMULATOR
+        // Use the backend, but no layers because not supported fully on simulator
+        cparams.use_gpu = false;
+        reasonNoMetal = @"Metal is not supported in simulator";
+#endif
+
+        device = nil;
     }
 #endif // WSP_GGML_USE_METAL
 

package/ios/RNWhisperVadContext.h

@@ -0,0 +1,29 @@
+#ifdef __cplusplus
+#if RNWHISPER_BUILD_FROM_SOURCE
+#import "whisper.h"
+#import "rn-whisper.h"
+#else
+#import <rnwhisper/whisper.h>
+#import <rnwhisper/rn-whisper.h>
+#endif
+#endif
+
+#import <Foundation/Foundation.h>
+
+@interface RNWhisperVadContext : NSObject {
+    int contextId;
+    dispatch_queue_t dQueue;
+    struct whisper_vad_context * vctx;
+    NSString * reasonNoMetal;
+    bool isMetalEnabled;
+}
+
++ (instancetype)initWithModelPath:(NSString *)modelPath contextId:(int)contextId noMetal:(BOOL)noMetal nThreads:(NSNumber *)nThreads;
+- (bool)isMetalEnabled;
+- (NSString *)reasonNoMetal;
+- (struct whisper_vad_context *)getVadContext;
+- (dispatch_queue_t)getDispatchQueue;
+- (NSArray *)detectSpeech:(float *)samples samplesCount:(int)samplesCount options:(NSDictionary *)options;
+- (void)invalidate;
+
+@end

package/ios/RNWhisperVadContext.mm

@@ -0,0 +1,148 @@
+#import "RNWhisperVadContext.h"
+#import "RNWhisperAudioUtils.h"
+#import <Metal/Metal.h>
+
+@implementation RNWhisperVadContext
+
++ (instancetype)initWithModelPath:(NSString *)modelPath contextId:(int)contextId noMetal:(BOOL)noMetal nThreads:(NSNumber *)nThreads {
+    RNWhisperVadContext *context = [[RNWhisperVadContext alloc] init];
+
+    context->contextId = contextId;
+    context->dQueue = dispatch_queue_create("rnwhisper.vad.serial_queue", DISPATCH_QUEUE_SERIAL);
+    NSString *reasonNoMetal = @"";
+
+    // Set up VAD context parameters
+    struct whisper_vad_context_params ctx_params = whisper_vad_default_context_params();
+    ctx_params.use_gpu = !noMetal;
+    if (nThreads != nil) {
+        ctx_params.n_threads = [nThreads intValue];
+    }
+
+#ifdef WSP_GGML_USE_METAL
+    if (ctx_params.use_gpu) {
+        id<MTLDevice> device = MTLCreateSystemDefaultDevice();
+
+        // Check ggml-metal availability
+        BOOL supportsGgmlMetal = [device supportsFamily:MTLGPUFamilyApple7];
+        if (@available(iOS 16.0, tvOS 16.0, *)) {
+            supportsGgmlMetal = supportsGgmlMetal && [device supportsFamily:MTLGPUFamilyMetal3];
+        }
+        if (!supportsGgmlMetal) {
+          ctx_params.use_gpu = false;
+            reasonNoMetal = @"Metal is not supported in this device";
+        }
+
+#if TARGET_OS_SIMULATOR
+        // Use the backend, but no layers because not supported fully on simulator
+        ctx_params.use_gpu = false;
+        reasonNoMetal = @"Metal is not supported in simulator";
+#endif
+
+        device = nil;
+    }
+#endif // WSP_GGML_USE_METAL
+
+    // Initialize VAD context
+    context->vctx = whisper_vad_init_from_file_with_params([modelPath UTF8String], ctx_params);
+
+    if (context->vctx == NULL) {
+        NSLog(@"Failed to initialize VAD context from model: %@", modelPath);
+        return nil;
+    }
+
+    // Check GPU status
+    context->isMetalEnabled = ctx_params.use_gpu;
+    context->reasonNoMetal = reasonNoMetal;
+
+    return context;
+}
+
+- (bool)isMetalEnabled {
+    return isMetalEnabled;
+}
+
+- (NSString *)reasonNoMetal {
+    return reasonNoMetal;
+}
+
+- (struct whisper_vad_context *)getVadContext {
+    return vctx;
+}
+
+- (dispatch_queue_t)getDispatchQueue {
+    return dQueue;
+}
+
+- (NSArray *)detectSpeech:(float *)samples samplesCount:(int)samplesCount options:(NSDictionary *)options {
+    if (vctx == NULL) {
+        NSLog(@"VAD context is null");
+        return @[];
+    }
+
+    // Run VAD detection
+    bool speechDetected = whisper_vad_detect_speech(vctx, samples, samplesCount);
+    if (!speechDetected) {
+        return @[];
+    }
+
+    // Get VAD parameters
+    struct whisper_vad_params vad_params = whisper_vad_default_params();
+
+    if ([options objectForKey:@"threshold"]) {
+        vad_params.threshold = [[options objectForKey:@"threshold"] floatValue];
+    }
+    if ([options objectForKey:@"minSpeechDurationMs"]) {
+        vad_params.min_speech_duration_ms = [[options objectForKey:@"minSpeechDurationMs"] intValue];
+    }
+    if ([options objectForKey:@"minSilenceDurationMs"]) {
+        vad_params.min_silence_duration_ms = [[options objectForKey:@"minSilenceDurationMs"] intValue];
+    }
+    if ([options objectForKey:@"maxSpeechDurationS"]) {
+        vad_params.max_speech_duration_s = [[options objectForKey:@"maxSpeechDurationS"] floatValue];
+    }
+    if ([options objectForKey:@"speechPadMs"]) {
+        vad_params.speech_pad_ms = [[options objectForKey:@"speechPadMs"] intValue];
+    }
+    if ([options objectForKey:@"samplesOverlap"]) {
+        vad_params.samples_overlap = [[options objectForKey:@"samplesOverlap"] floatValue];
+    }
+
+    // Get segments from VAD probabilities
+    struct whisper_vad_segments * segments = whisper_vad_segments_from_probs(vctx, vad_params);
+    if (segments == NULL) {
+        return @[];
+    }
+
+    // Convert segments to NSArray
+    NSMutableArray *result = [[NSMutableArray alloc] init];
+    int n_segments = whisper_vad_segments_n_segments(segments);
+
+    for (int i = 0; i < n_segments; i++) {
+        float t0 = whisper_vad_segments_get_segment_t0(segments, i);
+        float t1 = whisper_vad_segments_get_segment_t1(segments, i);
+
+        NSDictionary *segment = @{
+            @"t0": @(t0),
+            @"t1": @(t1)
+        };
+        [result addObject:segment];
+    }
+
+    // Clean up
+    whisper_vad_free_segments(segments);
+
+    return result;
+}
+
+- (void)invalidate {
+    if (vctx != NULL) {
+        whisper_vad_free(vctx);
+        vctx = NULL;
+    }
+}
+
+- (void)dealloc {
+    [self invalidate];
+}
+
+@end

package/jest/mock.js

@@ -61,6 +61,25 @@ if (!NativeModules.RNWhisper) {
     releaseContext: jest.fn(() => Promise.resolve()),
     releaseAllContexts: jest.fn(() => Promise.resolve()),
 
+    // VAD methods
+    initVadContext: jest.fn(() => Promise.resolve({
+      contextId: 2,
+      gpu: false,
+      reasonNoGPU: 'Mock VAD context'
+    })),
+    vadDetectSpeech: jest.fn().mockResolvedValue([
+      { t0: 0.5, t1: 2.3 },
+      { t0: 3.1, t1: 5.8 },
+      { t0: 7.2, t1: 9.4 }
+    ]),
+    vadDetectSpeechFile: jest.fn().mockResolvedValue([
+      { t0: 0.5, t1: 2.3 },
+      { t0: 3.1, t1: 5.8 },
+      { t0: 7.2, t1: 9.4 }
+    ]),
+    releaseVadContext: jest.fn(() => Promise.resolve()),
+    releaseAllVadContexts: jest.fn(() => Promise.resolve()),
+
     // iOS AudioSession utils
     getAudioSessionCurrentCategory: jest.fn(() => Promise.resolve({
       category: 'AVAudioSessionCategoryPlayAndRecord',

package/lib/commonjs/NativeRNWhisper.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_default","TurboModuleRegistry","get","exports","default"],"sourceRoot":"../../src","sources":["NativeRNWhisper.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAkD,IAAAC,QAAA,GA0GnCC,gCAAmB,CAACC,GAAG,CAAO,WAAW,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAJ,QAAA"}
+{"version":3,"names":["_reactNative","require","_default","TurboModuleRegistry","get","exports","default"],"sourceRoot":"../../src","sources":["NativeRNWhisper.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAkD,IAAAC,QAAA,GA0JnCC,gCAAmB,CAACC,GAAG,CAAO,WAAW,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAJ,QAAA"}

package/lib/commonjs/index.js

@@ -9,10 +9,12 @@ Object.defineProperty(exports, "AudioSessionIos", {
     return _AudioSessionIos.default;
   }
 });
-exports.WhisperContext = void 0;
+exports.WhisperVadContext = exports.WhisperContext = void 0;
 exports.initWhisper = initWhisper;
+exports.initWhisperVad = initWhisperVad;
 exports.libVersion = exports.isUseCoreML = exports.isCoreMLAllowFallback = void 0;
 exports.releaseAllWhisper = releaseAllWhisper;
+exports.releaseAllWhisperVad = releaseAllWhisperVad;
 var _reactNative = require("react-native");
 var _NativeRNWhisper = _interopRequireDefault(require("./NativeRNWhisper"));
 var _AudioSessionIos = _interopRequireDefault(require("./AudioSessionIos"));
@@ -386,4 +388,112 @@ const isUseCoreML = !!useCoreML;
 exports.isUseCoreML = isUseCoreML;
 const isCoreMLAllowFallback = !!coreMLAllowFallback;
 exports.isCoreMLAllowFallback = isCoreMLAllowFallback;
+class WhisperVadContext {
+  gpu = false;
+  reasonNoGPU = '';
+  constructor(_ref3) {
+    let {
+      contextId,
+      gpu,
+      reasonNoGPU
+    } = _ref3;
+    this.id = contextId;
+    this.gpu = gpu;
+    this.reasonNoGPU = reasonNoGPU;
+  }
+
+  /**
+   * Detect speech segments in audio file (path or base64 encoded wav file)
+   * base64: need add `data:audio/wav;base64,` prefix
+   */
+  async detectSpeech(filePathOrBase64) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let path = '';
+    if (typeof filePathOrBase64 === 'number') {
+      try {
+        const source = _reactNative.Image.resolveAssetSource(filePathOrBase64);
+        if (source) path = source.uri;
+      } catch (e) {
+        throw new Error(`Invalid asset: ${filePathOrBase64}`);
+      }
+    } else {
+      if (filePathOrBase64.startsWith('http')) throw new Error('VAD remote file is not supported, please download it first');
+      path = filePathOrBase64;
+    }
+    if (path.startsWith('file://')) path = path.slice(7);
+
+    // Check if this is base64 encoded audio data
+    if (path.startsWith('data:audio/')) {
+      // This is base64 encoded audio data, use the raw data method
+      return _NativeRNWhisper.default.vadDetectSpeech(this.id, path, options);
+    } else {
+      // This is a file path, use the file method
+      return _NativeRNWhisper.default.vadDetectSpeechFile(this.id, path, options);
+    }
+  }
+
+  /**
+   * Detect speech segments in raw audio data (base64 encoded float32 PCM data)
+   */
+  async detectSpeechData(audioData) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return _NativeRNWhisper.default.vadDetectSpeech(this.id, audioData, options);
+  }
+  async release() {
+    return _NativeRNWhisper.default.releaseVadContext(this.id);
+  }
+}
+
+/**
+ * Initialize a VAD context for voice activity detection
+ * @param options VAD context options
+ * @returns Promise resolving to WhisperVadContext instance
+ */
+exports.WhisperVadContext = WhisperVadContext;
+async function initWhisperVad(_ref4) {
+  let {
+    filePath,
+    isBundleAsset,
+    useGpu = true,
+    nThreads
+  } = _ref4;
+  let path = '';
+  if (typeof filePath === 'number') {
+    try {
+      const source = _reactNative.Image.resolveAssetSource(filePath);
+      if (source) {
+        path = source.uri;
+      }
+    } catch (e) {
+      throw new Error(`Invalid asset: ${filePath}`);
+    }
+  } else {
+    if (!isBundleAsset && filePath.startsWith('http')) throw new Error('VAD remote file is not supported, please download it first');
+    path = filePath;
+  }
+  if (path.startsWith('file://')) path = path.slice(7);
+  const {
+    contextId,
+    gpu,
+    reasonNoGPU
+  } = await _NativeRNWhisper.default.initVadContext({
+    filePath: path,
+    isBundleAsset: !!isBundleAsset,
+    useGpu,
+    nThreads
+  });
+  return new WhisperVadContext({
+    contextId,
+    gpu,
+    reasonNoGPU
+  });
+}
+
+/**
+ * Release all VAD contexts and free their memory
+ * @returns Promise resolving when all contexts are released
+ */
+async function releaseAllWhisperVad() {
+  return _NativeRNWhisper.default.releaseAllVadContexts();
+}
 //# sourceMappingURL=index.js.map