react-native-wakeword-sid 1.1.55 → 1.1.56

package/ios/KeyWordRNBridge/KeyWordRNBridge.m

@@ -104,6 +104,46 @@
 @implementation SVVerifierHolder
 @end
 
+// ============================================================
+// MARK: - Speaker Verification Mic Controller holder + delegate proxy
+// ============================================================
+
+@interface SVMicHolder : NSObject
+@property (nonatomic, strong) id controller;      // opaque Swift object (SpeakerVerificationMicController)
+@property (nonatomic, strong) NSString *controllerId;
+@property (nonatomic, strong) id delegateProxy;   // ObjC proxy that receives Swift callbacks
+@end
+@implementation SVMicHolder @end
+
+@interface SVMicDelegateProxy : NSObject
+@property (nonatomic, weak) KeyWordRNBridge *bridge;
+@property (nonatomic, strong) NSString *controllerId;
+@end
+
+@implementation SVMicDelegateProxy
+- (void)svOnboardingProgress:(NSDictionary *)info {
+    NSMutableDictionary *m = info ? [info mutableCopy] : [NSMutableDictionary new];
+    m[@"controllerId"] = self.controllerId ?: @"";
+    [self.bridge sendEventWithName:@"onSpeakerVerificationOnboardingProgress" body:m];
+}
+- (void)svOnboardingDone:(NSDictionary *)info {
+    NSMutableDictionary *m = info ? [info mutableCopy] : [NSMutableDictionary new];
+    m[@"controllerId"] = self.controllerId ?: @"";
+    [self.bridge sendEventWithName:@"onSpeakerVerificationOnboardingDone" body:m];
+}
+- (void)svVerifyResult:(NSDictionary *)info {
+    NSMutableDictionary *m = info ? [info mutableCopy] : [NSMutableDictionary new];
+    m[@"controllerId"] = self.controllerId ?: @"";
+    [self.bridge sendEventWithName:@"onSpeakerVerificationVerifyResult" body:m];
+}
+- (void)svError:(NSDictionary *)info {
+    NSMutableDictionary *m = info ? [info mutableCopy] : [NSMutableDictionary new];
+    m[@"controllerId"] = self.controllerId ?: @"";
+    [self.bridge sendEventWithName:@"onSpeakerVerificationError" body:m];
+}
+@end
+
+
 // Resolve a file path from:
 //  1) absolute path (exists)
 //  2) main bundle resource "name.ext"
@@ -175,6 +215,44 @@ static Class SVFacadeClass(void) {
     return NSClassFromString(@"SpeakerVerificationRNFacade");
 }
 
+
+// =========================
+// MARK: - Mic controller dynamic bridge
+// =========================
+
+static id _Nullable SVCreateMicController(NSString *configJson, NSError **error) {
+    Class c = SVFacadeClass();
+    if (!c) {
+        if (error) *error = [NSError errorWithDomain:@"SV" code:10 userInfo:@{NSLocalizedDescriptionKey: @"Swift class SpeakerVerificationRNFacade not found"}];
+        return nil;
+    }
+    SEL sel = NSSelectorFromString(@"createMicControllerWithConfigJson:error:");
+    if (![c respondsToSelector:sel]) {
+        if (error) *error = [NSError errorWithDomain:@"SV" code:11 userInfo:@{NSLocalizedDescriptionKey: @"Missing selector createMicControllerWithConfigJson:error:"}];
+        return nil;
+    }
+    id (*msgSend)(id, SEL, NSString*, NSError**) = (void*)objc_msgSend;
+    return msgSend(c, sel, configJson, error);
+}
+
+static BOOL SVCallBool2(id obj, SEL sel, NSString *s1, NSInteger i1, BOOL b1, NSError **error) {
+    BOOL (*msgSend)(id, SEL, NSString*, NSInteger, BOOL, NSError**) = (void*)objc_msgSend;
+    return msgSend(obj, sel, s1, i1, b1, error);
+}
+static BOOL SVCallBool1(id obj, SEL sel, NSError **error) {
+    BOOL (*msgSend)(id, SEL, NSError**) = (void*)objc_msgSend;
+    return msgSend(obj, sel, error);
+}
+static BOOL SVCallBoolReset(id obj, SEL sel, BOOL b1, NSError **error) {
+    BOOL (*msgSend)(id, SEL, BOOL, NSError**) = (void*)objc_msgSend;
+    return msgSend(obj, sel, b1, error);
+}
+static void SVSetDelegate(id obj, id delegateObj) {
+    void (*msgSend)(id, SEL, id) = (void*)objc_msgSend;
+    msgSend(obj, NSSelectorFromString(@"setDelegate:"), delegateObj);
+}
+
+
 static id _Nullable SVCreateEngine(NSString *modelPath, NSString *jsonPath, NSDictionary *options, NSError **error) {
     Class c = SVFacadeClass();
     if (!c) {
@@ -209,6 +287,7 @@ static NSDictionary * _Nullable SVVerifyWav(id engine, NSString *wavPath, BOOL r
 
 @property (nonatomic, strong) NSMutableDictionary *instances;
 @property (nonatomic, strong) NSMutableDictionary *speakerVerifiers; // { engineId: SVVerifierHolder }
+@property (nonatomic, strong) NSMutableDictionary *speakerMicControllers; // { controllerId: SVMicHolder }
 
 @end
 
@@ -220,6 +299,7 @@ RCT_EXPORT_MODULE();
     if (self = [super init]) {
         _instances = [NSMutableDictionary new];
         _speakerVerifiers = [NSMutableDictionary new];
+        _speakerMicControllers = [NSMutableDictionary new];
     }
     return self;
 }
@@ -229,11 +309,17 @@ RCT_EXPORT_MODULE();
     return YES;
 }
 
+// NOTE: Extend supported events with Speaker Verification mic events
 - (NSArray<NSString *> *)supportedEvents {
     return @[@"onKeywordDetectionEvent",
-             @"onVADDetectionEvent"];  // NEW
+             @"onVADDetectionEvent",
+             @"onSpeakerVerificationOnboardingProgress",
+             @"onSpeakerVerificationOnboardingDone",
+             @"onSpeakerVerificationVerifyResult",
+             @"onSpeakerVerificationError"];
 }
 
+
 // ============================================================
 // MARK: - Speaker Verification (Swift) - RN APIs
 // ============================================================
@@ -340,6 +426,250 @@ RCT_EXPORT_METHOD(destroySpeakerVerifier:(NSString *)engineId
     resolve(@{ @"ok": @YES, @"engineId": engineId });
 }
 
+ 
+// ============================================================
+// MARK: - Speaker Verification Mic Controller (Swift) - RN APIs
+// ============================================================
+
+// Create mic controller from config JSON (SpeakerVerificationConfig).
+// Returns controllerId.
+RCT_EXPORT_METHOD(createSpeakerVerificationMicController:(NSString *)controllerId
+                  configJson:(NSString *)configJson
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (self.speakerMicControllers[controllerId]) {
+        reject(@"SVMicExists", [NSString stringWithFormat:@"Speaker mic controller already exists with ID: %@", controllerId], nil);
+        return;
+    }
+
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+            NSError *err = nil;
+            id ctrl = SVCreateMicController(configJson, &err);
+            if (err || !ctrl) {
+                reject(@"SVMicCreateError",
+                       [NSString stringWithFormat:@"Failed to create mic controller: %@", err.localizedDescription ?: @"unknown"],
+                       err);
+                return;
+            }
+
+            // Create delegate proxy that will forward Swift callbacks -> RN events
+            SVMicDelegateProxy *proxy = [SVMicDelegateProxy new];
+            proxy.bridge = self;
+            proxy.controllerId = controllerId;
+
+            // Set delegate dynamically (no header needed)
+            SVSetDelegate(ctrl, proxy);
+
+            SVMicHolder *h = [SVMicHolder new];
+            h.controllerId = controllerId;
+            h.controller = ctrl;
+            h.delegateProxy = proxy; // keep strong ref
+            self.speakerMicControllers[controllerId] = h;
+
+            resolve(@{ @"ok": @YES, @"controllerId": controllerId });
+        }
+    });
+}
+
+RCT_EXPORT_METHOD(destroySpeakerVerificationMicController:(NSString *)controllerId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+
+    // Best-effort stop (no throw)
+    if (h.controller && [h.controller respondsToSelector:NSSelectorFromString(@"stop")]) {
+        void (*msgSend)(id, SEL) = (void*)objc_msgSend;
+        msgSend(h.controller, NSSelectorFromString(@"stop"));
+    }
+
+    [self.speakerMicControllers removeObjectForKey:controllerId];
+    resolve(@{ @"ok": @YES, @"controllerId": controllerId });
+}
+
+// beginOnboarding(enrollmentId, targetEmbeddingCount, reset)
+RCT_EXPORT_METHOD(svBeginOnboarding:(NSString *)controllerId
+                  enrollmentId:(NSString *)enrollmentId
+                  targetEmbeddingCount:(NSInteger)targetEmbeddingCount
+                  reset:(BOOL)reset
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h || !h.controller) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+            NSError *err = nil;
+            SEL sel = NSSelectorFromString(@"beginOnboardingWithEnrollmentId:targetEmbeddingCount:reset:error:");
+            if (![h.controller respondsToSelector:sel]) {
+                reject(@"SVMicMissingSelector", @"Mic controller missing beginOnboardingWithEnrollmentId:targetEmbeddingCount:reset:error:", nil);
+                return;
+            }
+            BOOL ok = SVCallBool2(h.controller, sel, enrollmentId, targetEmbeddingCount, reset, &err);
+            if (!ok || err) {
+                reject(@"SVMicBeginError",
+                       [NSString stringWithFormat:@"beginOnboarding failed: %@", err.localizedDescription ?: @"unknown"],
+                       err);
+                return;
+            }
+            resolve(@{ @"ok": @YES, @"controllerId": controllerId, @"enrollmentId": enrollmentId, @"target": @(targetEmbeddingCount) });
+        }
+    });
+}
+
+// getNextEmbeddingFromMic(): starts mic, collects ONE embedding, then stops mic.
+// Result is delivered via event:
+//   onSpeakerVerificationOnboardingProgress / onSpeakerVerificationOnboardingDone
+RCT_EXPORT_METHOD(svGetNextEmbeddingFromMic:(NSString *)controllerId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h || !h.controller) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+            NSError *err = nil;
+            SEL sel = NSSelectorFromString(@"getNextEmbeddingFromMicAndReturnError:");
+            if (![h.controller respondsToSelector:sel]) {
+                reject(@"SVMicMissingSelector", @"Mic controller missing getNextEmbeddingFromMicAndReturnError:", nil);
+                return;
+            }
+            BOOL ok = SVCallBool1(h.controller, sel, &err);
+            if (!ok || err) {
+                reject(@"SVMicGetNextError",
+                       [NSString stringWithFormat:@"getNextEmbeddingFromMic failed: %@", err.localizedDescription ?: @"unknown"],
+                       err);
+                return;
+            }
+            resolve(@{ @"ok": @YES, @"controllerId": controllerId });
+        }
+    });
+}
+
+// finalizeOnboardingNow(): forces finalize and emits onSpeakerVerificationOnboardingDone (from Swift delegate)
+RCT_EXPORT_METHOD(svFinalizeOnboardingNow:(NSString *)controllerId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h || !h.controller) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+            NSError *err = nil;
+            SEL sel = NSSelectorFromString(@"finalizeOnboardingNowAndReturnError:");
+            if (![h.controller respondsToSelector:sel]) {
+                reject(@"SVMicMissingSelector", @"Mic controller missing finalizeOnboardingNowAndReturnError:", nil);
+                return;
+            }
+            BOOL ok = SVCallBool1(h.controller, sel, &err);
+            if (!ok || err) {
+                reject(@"SVMicFinalizeError",
+                       [NSString stringWithFormat:@"finalizeOnboardingNow failed: %@", err.localizedDescription ?: @"unknown"],
+                       err);
+                return;
+            }
+            resolve(@{ @"ok": @YES, @"controllerId": controllerId });
+        }
+    });
+}
+
+// setEnrollmentJson(enrollmentJson): sets enrollment for verification mode
+RCT_EXPORT_METHOD(svSetEnrollmentJson:(NSString *)controllerId
+                  enrollmentJson:(NSString *)enrollmentJson
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h || !h.controller) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+            NSError *err = nil;
+            SEL sel = NSSelectorFromString(@"setEnrollmentJson:error:");
+            if (![h.controller respondsToSelector:sel]) {
+                reject(@"SVMicMissingSelector", @"Mic controller missing setEnrollmentJson:error:", nil);
+                return;
+            }
+            BOOL (*msgSend)(id, SEL, NSString*, NSError**) = (void*)objc_msgSend;
+            BOOL ok = msgSend(h.controller, sel, enrollmentJson, &err);
+            if (!ok || err) {
+                reject(@"SVMicSetEnrollError",
+                       [NSString stringWithFormat:@"setEnrollmentJson failed: %@", err.localizedDescription ?: @"unknown"],
+                       err);
+                return;
+            }
+            resolve(@{ @"ok": @YES, @"controllerId": controllerId });
+        }
+    });
+}
+
+// startVerifyFromMic(resetState): starts mic until a verification result is produced.
+// Result delivered via event: onSpeakerVerificationVerifyResult
+RCT_EXPORT_METHOD(svStartVerifyFromMic:(NSString *)controllerId
+                  resetState:(BOOL)resetState
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h || !h.controller) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+            NSError *err = nil;
+            SEL sel = NSSelectorFromString(@"startVerifyFromMicWithResetState:error:");
+            if (![h.controller respondsToSelector:sel]) {
+                reject(@"SVMicMissingSelector", @"Mic controller missing startVerifyFromMicWithResetState:error:", nil);
+                return;
+            }
+            BOOL ok = SVCallBoolReset(h.controller, sel, resetState, &err);
+            if (!ok || err) {
+                reject(@"SVMicStartVerifyError",
+                       [NSString stringWithFormat:@"startVerifyFromMic failed: %@", err.localizedDescription ?: @"unknown"],
+                       err);
+                return;
+            }
+            resolve(@{ @"ok": @YES, @"controllerId": controllerId, @"resetState": @(resetState) });
+        }
+    });
+}
+
+// stop(): stop mic immediately
+RCT_EXPORT_METHOD(svStopMic:(NSString *)controllerId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    SVMicHolder *h = self.speakerMicControllers[controllerId];
+    if (!h || !h.controller) {
+        reject(@"SVMicNotFound", [NSString stringWithFormat:@"No speaker mic controller with ID: %@", controllerId], nil);
+        return;
+    }
+    if ([h.controller respondsToSelector:NSSelectorFromString(@"stop")]) {
+        void (*msgSend)(id, SEL) = (void*)objc_msgSend;
+        msgSend(h.controller, NSSelectorFromString(@"stop"));
+    }
+    resolve(@{ @"ok": @YES, @"controllerId": controllerId });
+}
 
 RCT_EXPORT_METHOD(createInstanceMulti:(NSString *)instanceId
                   modelPaths:(NSArray<NSString *> *)modelPaths
@@ -411,7 +741,7 @@ RCT_EXPORT_METHOD(setAudioRoutingConfig:(NSString *)jsonConfig
 RCT_EXPORT_METHOD(disableDucking:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
   [AudioSessionAndDuckingManager.shared disableDucking];
-  resolve(@"enabled");
+  resolve(@"disabled");
 }
 
 RCT_EXPORT_METHOD(initAudioSessAndDuckManage:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-wakeword-sid",
-    "version": "1.1.55",
+    "version": "1.1.56",
     "description": "Voice/Wake-word detection library for React Native",
     "main": "wakewords/index.js",
     "types": "wakewords/index.d.ts",

package/wakewords/SpeakerVerificationRNBridge.d.ts

@@ -30,3 +30,20 @@ export class SpeakerVerificationRNBridgeInstance {
     destroy(): Promise<any>;
 }
 export function createSpeakerVerificationInstance(engineId: any): Promise<SpeakerVerificationRNBridgeInstance>;
+export class SpeakerVerificationMicController {
+    constructor(controllerId: any);
+    controllerId: any;
+    create(configJson: any): Promise<any>;
+    beginOnboarding(enrollmentId: any, targetEmbeddingCount: any, reset?: boolean): Promise<any>;
+    getNextEmbeddingFromMic(): Promise<any>;
+    finalizeOnboardingNow(): Promise<any>;
+    setEnrollmentJson(enrollmentJson: any): Promise<any>;
+    startVerifyFromMic(resetState?: boolean): Promise<any>;
+    stop(): Promise<any>;
+    destroy(): Promise<any>;
+}
+export function createSpeakerVerificationMicController(controllerId: any): Promise<SpeakerVerificationMicController>;
+export function onSpeakerVerificationOnboardingProgress(cb: any): () => void;
+export function onSpeakerVerificationOnboardingDone(cb: any): () => void;
+export function onSpeakerVerificationVerifyResult(cb: any): () => void;
+export function onSpeakerVerificationError(cb: any): () => void;

package/wakewords/SpeakerVerificationRNBridge.js

@@ -1,9 +1,10 @@
 // wakewords/SpeakerVerificationRNBridge.js
-import { NativeModules, Platform } from 'react-native';
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
 import resolveAssetSource from 'react-native/Libraries/Image/resolveAssetSource';
 
 // Keep using the SAME native module (KeyWordRNBridge.m already exports these methods)
 const { KeyWordRNBridge } = NativeModules;
+const emitter = KeyWordRNBridge ? new NativeEventEmitter(KeyWordRNBridge) : null;
 
 function stripFileScheme(uri) {
   if (!uri) return uri;
@@ -35,6 +36,18 @@ function normalizePathOrName(input) {
   return String(input);
 }
 
+function assertIOS() {
+  if (Platform.OS !== 'ios') {
+    throw new Error('Speaker verification bridge is currently implemented for iOS only.');
+  }
+}
+
+function assertMethod(name) {
+  if (!KeyWordRNBridge?.[name]) {
+    throw new Error(`KeyWordRNBridge.${name} is not available (native not linked / iOS only?)`);
+  }
+}
+
 export class SpeakerVerificationRNBridgeInstance {
   engineId;
 
@@ -57,13 +70,8 @@ export class SpeakerVerificationRNBridgeInstance {
    *   { decisionThreshold, frameSize, tailSeconds, maxTailSeconds, cmn, expectedLayoutBDT, logLevel }
    */
   async create(modelPathOrName, enrollmentJsonPathOrName, options = {}) {
-    if (!KeyWordRNBridge?.createSpeakerVerifier) {
-      throw new Error('KeyWordRNBridge.createSpeakerVerifier is not available (native not linked / iOS only?)');
-    }
-
-    if (Platform.OS !== 'ios') {
-      throw new Error('Speaker verification bridge is currently implemented for iOS only.');
-    }
+    assertIOS();
+    assertMethod('createSpeakerVerifier');
 
     const modelArg = normalizePathOrName(modelPathOrName);
     const jsonArg = normalizePathOrName(enrollmentJsonPathOrName);
@@ -87,13 +95,8 @@ export class SpeakerVerificationRNBridgeInstance {
    *   - if true, clears internal streaming state before verification
    */
   async verifyWavStreaming(wavPathOrName, resetState = true) {
-    if (!KeyWordRNBridge?.verifySpeakerWavStreaming) {
-      throw new Error('KeyWordRNBridge.verifySpeakerWavStreaming is not available (native not linked / iOS only?)');
-    }
-
-    if (Platform.OS !== 'ios') {
-      throw new Error('Speaker verification bridge is currently implemented for iOS only.');
-    }
+    assertIOS();
+    assertMethod('verifySpeakerWavStreaming');
 
     const wavArg = normalizePathOrName(wavPathOrName);
 
@@ -105,15 +108,12 @@ export class SpeakerVerificationRNBridgeInstance {
   }
 
   async destroy() {
-    if (!KeyWordRNBridge?.destroySpeakerVerifier) {
-      throw new Error('KeyWordRNBridge.destroySpeakerVerifier is not available (native not linked / iOS only?)');
-    }
 
     if (Platform.OS !== 'ios') {
       // no-op for now
       return { ok: true, engineId: this.engineId, noop: true };
     }
-
+    assertMethod('destroySpeakerVerifier');
     return await KeyWordRNBridge.destroySpeakerVerifier(this.engineId);
   }
 }
@@ -122,3 +122,118 @@ export class SpeakerVerificationRNBridgeInstance {
 export const createSpeakerVerificationInstance = async (engineId) => {
   return new SpeakerVerificationRNBridgeInstance(engineId);
 };
+
+// ============================================================
+// MARK: - Speaker Verification Mic Controller (Swift) - RN APIs
+// ============================================================
+export class SpeakerVerificationMicController {
+  controllerId;
+
+  constructor(controllerId) {
+    this.controllerId = controllerId;
+  }
+
+  async create(configJson) {
+    assertIOS();
+    assertMethod('createSpeakerVerificationMicController');
+    const cfg =
+      typeof configJson === 'string'
+        ? configJson
+        : JSON.stringify(configJson ?? {});
+    return await KeyWordRNBridge.createSpeakerVerificationMicController(
+      this.controllerId,
+      cfg
+    );
+  }
+
+  async beginOnboarding(enrollmentId, targetEmbeddingCount, reset = true) {
+    assertIOS();
+    assertMethod('svBeginOnboarding');
+    return await KeyWordRNBridge.svBeginOnboarding(
+      this.controllerId,
+      String(enrollmentId ?? ''),
+      Number(targetEmbeddingCount ?? 0),
+      !!reset
+    );
+  }
+
+  async getNextEmbeddingFromMic() {
+    assertIOS();
+    assertMethod('svGetNextEmbeddingFromMic');
+    return await KeyWordRNBridge.svGetNextEmbeddingFromMic(this.controllerId);
+  }
+
+  async finalizeOnboardingNow() {
+    assertIOS();
+    assertMethod('svFinalizeOnboardingNow');
+    return await KeyWordRNBridge.svFinalizeOnboardingNow(this.controllerId);
+  }
+
+  async setEnrollmentJson(enrollmentJson) {
+    assertIOS();
+    assertMethod('svSetEnrollmentJson');
+    // if caller passes object, stringify it (native expects JSON string)
+    const s =
+      typeof enrollmentJson === 'string'
+        ? enrollmentJson
+        : JSON.stringify(enrollmentJson ?? {});
+
+    return await KeyWordRNBridge.svSetEnrollmentJson(
+      this.controllerId,
+      s
+    );
+  }
+
+  async startVerifyFromMic(resetState = true) {
+    assertIOS();
+    assertMethod('svStartVerifyFromMic');
+    return await KeyWordRNBridge.svStartVerifyFromMic(
+      this.controllerId,
+      !!resetState
+    );
+  }
+
+  async stop() {
+    if (Platform.OS !== 'ios') {
+      return { ok: true, controllerId: this.controllerId, noop: true };
+    }
+    assertMethod('svStopMic');
+    return await KeyWordRNBridge.svStopMic(this.controllerId);
+  }
+
+  async destroy() {
+    if (Platform.OS !== 'ios') {
+      return { ok: true, controllerId: this.controllerId, noop: true };
+    }
+    assertMethod('destroySpeakerVerificationMicController');
+    return await KeyWordRNBridge.destroySpeakerVerificationMicController(this.controllerId);
+  }
+}
+
+export const createSpeakerVerificationMicController = async (controllerId) => {
+  return new SpeakerVerificationMicController(controllerId);
+};
+
+// ============================================================
+// MARK: - Event helpers
+// ============================================================
+
+function onEvent(eventName, cb) {
+  if (!emitter) {
+    throw new Error('NativeEventEmitter unavailable: KeyWordRNBridge is not linked.');
+  }
+  const sub = emitter.addListener(eventName, cb);
+  return () => sub.remove();
+}
+
+export const onSpeakerVerificationOnboardingProgress = (cb) =>
+  onEvent('onSpeakerVerificationOnboardingProgress', cb);
+
+export const onSpeakerVerificationOnboardingDone = (cb) =>
+  onEvent('onSpeakerVerificationOnboardingDone', cb);
+
+export const onSpeakerVerificationVerifyResult = (cb) =>
+  onEvent('onSpeakerVerificationVerifyResult', cb);
+
+export const onSpeakerVerificationError = (cb) =>
+  onEvent('onSpeakerVerificationError', cb);

package/wakewords/index.d.ts

@@ -9,8 +9,14 @@ import { KeyWordRNBridgeInstance } from './KeyWordRNBridge';
 import { setWakewordAudioRoutingConfig } from './KeyWordRNBridge';
 import { createSpeakerVerificationInstance } from './SpeakerVerificationRNBridge';
 import { SpeakerVerificationRNBridgeInstance } from './SpeakerVerificationRNBridge';
+import { createSpeakerVerificationMicController } from './SpeakerVerificationRNBridge';
+import { SpeakerVerificationMicController } from './SpeakerVerificationRNBridge';
+import { onSpeakerVerificationOnboardingProgress } from './SpeakerVerificationRNBridge';
+import { onSpeakerVerificationOnboardingDone } from './SpeakerVerificationRNBridge';
+import { onSpeakerVerificationVerifyResult } from './SpeakerVerificationRNBridge';
+import { onSpeakerVerificationError } from './SpeakerVerificationRNBridge';
 import useModel from './useModel';
-export { enableDucking, disableDucking, initAudioSessAndDuckManage, restartListeningAfterDucking, removeAllRNBridgeListeners, createKeyWordRNBridgeInstance, KeyWordRNBridgeInstance, setWakewordAudioRoutingConfig, createSpeakerVerificationInstance, SpeakerVerificationRNBridgeInstance, useModel };
+export { enableDucking, disableDucking, initAudioSessAndDuckManage, restartListeningAfterDucking, removeAllRNBridgeListeners, createKeyWordRNBridgeInstance, KeyWordRNBridgeInstance, setWakewordAudioRoutingConfig, createSpeakerVerificationInstance, SpeakerVerificationRNBridgeInstance, createSpeakerVerificationMicController, SpeakerVerificationMicController, onSpeakerVerificationOnboardingProgress, onSpeakerVerificationOnboardingDone, onSpeakerVerificationVerifyResult, onSpeakerVerificationError, useModel };
 
 // Re-export routing types for consumers:
 export type { AudioRoutingConfig, RouteConfigEntry } from './audioRoutingConfig';

package/wakewords/index.js

@@ -16,6 +16,12 @@ import {
 import {
   createSpeakerVerificationInstance,
   SpeakerVerificationRNBridgeInstance,
+  createSpeakerVerificationMicController,
+  SpeakerVerificationMicController,
+  onSpeakerVerificationOnboardingProgress,
+  onSpeakerVerificationOnboardingDone,
+  onSpeakerVerificationVerifyResult,
+  onSpeakerVerificationError,
 } from './SpeakerVerificationRNBridge';
 
 export { enableDucking }
@@ -30,5 +36,15 @@ export { setWakewordAudioRoutingConfig }  // ← NEW
 export { createSpeakerVerificationInstance };          // ✅ NEW
 export { SpeakerVerificationRNBridgeInstance };        // ✅ NEW
 
+// ✅ NEW speaker verification mic controller exports
+export { createSpeakerVerificationMicController };
+export { SpeakerVerificationMicController };
+export {
+  onSpeakerVerificationOnboardingProgress,
+  onSpeakerVerificationOnboardingDone,
+  onSpeakerVerificationVerifyResult,
+  onSpeakerVerificationError,
+};
+ 
 export { useModel }; // Export only useModel
 export default useModel; // Allow default import