@runanywhere/core 0.17.2 → 0.17.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runanywhere/core",
-  "version": "0.17.2",
+  "version": "0.17.3",
   "description": "Core SDK for RunAnywhere React Native - includes RACommons bindings, native bridges, and public API",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/Features/VoiceSession/AudioCaptureManager.ts

@@ -8,11 +8,41 @@
  */
 
 import { Platform, PermissionsAndroid, NativeModules } from 'react-native';
-import { EventBus } from '../../Public/Events';
 import { SDKLogger } from '../../Foundation/Logging/Logger/SDKLogger';
 
 const logger = new SDKLogger('AudioCaptureManager');
 
+// Lazy-load EventBus to avoid circular dependency issues during module initialization
+// The circular dependency: AudioCaptureManager -> EventBus -> SDKLogger -> ... -> AudioCaptureManager
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _eventBus: any = null;
+function getEventBus() {
+  if (!_eventBus) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      _eventBus = require('../../Public/Events').EventBus;
+    } catch {
+      logger.warning('EventBus not available');
+    }
+  }
+  return _eventBus;
+}
+
+/**
+ * Safely publish an event to the EventBus
+ * Handles cases where EventBus may not be fully initialized
+ */
+function safePublish(eventType: string, event: Record<string, unknown>): void {
+  try {
+    const eventBus = getEventBus();
+    if (eventBus?.publish) {
+      eventBus.publish(eventType, event);
+    }
+  } catch {
+    // Ignore EventBus errors - events are non-critical for audio functionality
+  }
+}
+
 // Native iOS Audio Module (provided by the app)
 const NativeAudioModule = Platform.OS === 'ios' ? NativeModules.NativeAudioModule : null;
 
@@ -156,7 +186,7 @@ export class AudioCaptureManager {
     this.state = 'recording';
 
     logger.info('Starting audio recording...');
-    EventBus.publish('Voice', { type: 'recordingStarted' });
+    safePublish('Voice', { type: 'recordingStarted' });
 
     if (Platform.OS === 'ios') {
       await this.startIOSRecording();
@@ -186,7 +216,7 @@ export class AudioCaptureManager {
       path = await this.stopAndroidRecording();
     }
 
-    EventBus.publish('Voice', { type: 'recordingStopped', duration: durationMs / 1000 });
+    safePublish('Voice', { type: 'recordingStopped', duration: durationMs / 1000 });
 
     this.audioDataCallback = null;
     this.recordingStartTime = null;

package/src/Features/VoiceSession/AudioPlaybackManager.ts

@@ -8,11 +8,26 @@
  */
 
 import { Platform, NativeModules } from 'react-native';
-import { EventBus } from '../../Public/Events';
 import { SDKLogger } from '../../Foundation/Logging/Logger/SDKLogger';
 
 const logger = new SDKLogger('AudioPlaybackManager');
 
+/**
+ * Safely publish an event to the EventBus
+ * Uses lazy loading to avoid circular dependency issues during module initialization
+ */
+function safePublish(eventType: string, event: Record<string, unknown>): void {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { EventBus } = require('../../Public/Events');
+    if (EventBus?.publish) {
+      EventBus.publish(eventType, event);
+    }
+  } catch {
+    // Ignore EventBus errors - events are non-critical for playback functionality
+  }
+}
+
 // Native iOS Audio Module
 const NativeAudioModule = Platform.OS === 'ios' ? NativeModules.NativeAudioModule : null;
 
@@ -151,7 +166,7 @@ export class AudioPlaybackManager {
       this.state = 'error';
       const err = error instanceof Error ? error : new Error(String(error));
       logger.error(`Playback failed: ${err.message}`);
-      EventBus.publish('Voice', { type: 'playbackFailed', error: err.message });
+      safePublish('Voice', { type: 'playbackFailed', error: err.message });
 
       if (this.errorCallback) {
         this.errorCallback(err);
@@ -168,7 +183,7 @@ export class AudioPlaybackManager {
     this.state = 'playing';
 
     logger.info(`Playing audio file: ${filePath}`);
-    EventBus.publish('Voice', { type: 'playbackStarted' });
+    safePublish('Voice', { type: 'playbackStarted' });
 
     if (Platform.OS === 'ios') {
       await this.playFileIOS(filePath);
@@ -196,7 +211,7 @@ export class AudioPlaybackManager {
       this.currentSound = null;
     }
 
-    EventBus.publish('Voice', { type: 'playbackStopped' });
+    safePublish('Voice', { type: 'playbackStopped' });
 
     if (this.completionCallback) {
       this.completionCallback();
@@ -217,7 +232,7 @@ export class AudioPlaybackManager {
       }
 
       logger.info('Playback paused');
-      EventBus.publish('Voice', { type: 'playbackPaused' });
+      safePublish('Voice', { type: 'playbackPaused' });
     }
   }
 
@@ -235,7 +250,7 @@ export class AudioPlaybackManager {
       }
 
       logger.info('Playback resumed');
-      EventBus.publish('Voice', { type: 'playbackResumed' });
+      safePublish('Voice', { type: 'playbackResumed' });
     }
   }
 
@@ -389,7 +404,7 @@ export class AudioPlaybackManager {
 
     logger.info(`Playback completed (${duration.toFixed(2)}s)`);
 
-    EventBus.publish('Voice', {
+    safePublish('Voice', {
       type: 'playbackCompleted',
       duration,
     });

package/src/Features/VoiceSession/VoiceSessionHandle.ts

@@ -28,9 +28,38 @@
  * ```
  */
 
-import { EventBus } from '../../Public/Events';
 import { SDKLogger } from '../../Foundation/Logging/Logger/SDKLogger';
 import { AudioCaptureManager } from './AudioCaptureManager';
+
+// Lazy-load EventBus to avoid circular dependency issues during module initialization
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _eventBus: any = null;
+function getEventBus() {
+  if (!_eventBus) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      _eventBus = require('../../Public/Events').EventBus;
+    } catch {
+      // EventBus not available
+    }
+  }
+  return _eventBus;
+}
+
+/**
+ * Safely publish an event to the EventBus
+ * Handles cases where EventBus may not be fully initialized due to circular dependencies
+ */
+function safePublish(eventType: string, event: Record<string, unknown>): void {
+  try {
+    const eventBus = getEventBus();
+    if (eventBus?.publish) {
+      eventBus.publish(eventType, event);
+    }
+  } catch {
+    // Ignore EventBus errors - events are non-critical for voice session functionality
+  }
+}
 import { AudioPlaybackManager } from './AudioPlaybackManager';
 import * as STT from '../../Public/Extensions/RunAnywhere+STT';
 import * as TextGeneration from '../../Public/Extensions/RunAnywhere+TextGeneration';
@@ -390,31 +419,31 @@ export class VoiceSessionHandle {
 
     switch (eventBusType) {
       case 'voiceSession_started':
-        EventBus.publish('Voice', { type: 'voiceSession_started' });
+        safePublish('Voice', { type: 'voiceSession_started' });
         break;
       case 'voiceSession_listening':
-        EventBus.publish('Voice', { type: 'voiceSession_listening', audioLevel: eventData.audioLevel });
+        safePublish('Voice', { type: 'voiceSession_listening', audioLevel: eventData.audioLevel });
         break;
       case 'voiceSession_speechStarted':
-        EventBus.publish('Voice', { type: 'voiceSession_speechStarted' });
+        safePublish('Voice', { type: 'voiceSession_speechStarted' });
         break;
       case 'voiceSession_speechEnded':
-        EventBus.publish('Voice', { type: 'voiceSession_speechEnded' });
+        safePublish('Voice', { type: 'voiceSession_speechEnded' });
         break;
       case 'voiceSession_processing':
-        EventBus.publish('Voice', { type: 'voiceSession_processing' });
+        safePublish('Voice', { type: 'voiceSession_processing' });
         break;
       case 'voiceSession_transcribed':
-        EventBus.publish('Voice', { type: 'voiceSession_transcribed', transcription: eventData.transcription });
+        safePublish('Voice', { type: 'voiceSession_transcribed', transcription: eventData.transcription });
         break;
       case 'voiceSession_responded':
-        EventBus.publish('Voice', { type: 'voiceSession_responded', response: eventData.response });
+        safePublish('Voice', { type: 'voiceSession_responded', response: eventData.response });
         break;
       case 'voiceSession_speaking':
-        EventBus.publish('Voice', { type: 'voiceSession_speaking' });
+        safePublish('Voice', { type: 'voiceSession_speaking' });
         break;
       case 'voiceSession_turnCompleted':
-        EventBus.publish('Voice', {
+        safePublish('Voice', {
           type: 'voiceSession_turnCompleted',
           transcription: eventData.transcription,
           response: eventData.response,
@@ -422,10 +451,10 @@ export class VoiceSessionHandle {
         });
         break;
       case 'voiceSession_stopped':
-        EventBus.publish('Voice', { type: 'voiceSession_stopped' });
+        safePublish('Voice', { type: 'voiceSession_stopped' });
         break;
       case 'voiceSession_error':
-        EventBus.publish('Voice', { type: 'voiceSession_error', error: eventData.error });
+        safePublish('Voice', { type: 'voiceSession_error', error: eventData.error });
         break;
     }
   }