@siteed/audio-studio 3.1.1 → 3.2.0-beta.1

package/ios/AudioStudioModule.swift

@@ -9,6 +9,10 @@ private let recordingInterruptedEvent: String = "onRecordingInterrupted"
 private let deviceChangedEvent: String = "deviceChangedEvent"
 private let trimProgressEvent: String = "TrimProgress"
 private let errorEvent: String = "error"
+private let audioStreamChunkEvent: String = "AudioDataStreamChunk"
+private let audioStreamProgressEvent: String = "AudioDataStreamProgress"
+private let audioStreamCompleteEvent: String = "AudioDataStreamComplete"
+private let audioStreamErrorEvent: String = "AudioDataStreamError"
 private let DEFAULT_SEGMENT_DURATION_MS = 100
 private let audioDeviceTypeBuiltinMic = "builtin_mic"
 private let audioDeviceTypeBluetooth = "bluetooth"
@@ -18,13 +22,16 @@ private let audioDeviceTypeWiredHeadphones = "wired_headphones"
 private let audioDeviceTypeSpeaker = "speaker"
 private let audioDeviceTypeUnknown = "unknown"
 
-public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceManagerDelegate {
+public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceManagerDelegate, AudioStreamDecoderDelegate {
     private var streamManager = AudioStreamManager()
     private let notificationCenter = UNUserNotificationCenter.current()
     private let notificationIdentifier = "audio_recording_notification"
     private var deviceManager = AudioDeviceManager()
     private var deviceChangeObserver: Any?
 
+    private let streamDecodersLock = NSLock()
+    private var streamDecoders: [String: AudioStreamDecoder] = [:]
+
     // Serial queue for AVAudioEngine lifecycle ops (prepare/start/stop).
     // Prevents concurrent mutation of shared engine state and keeps callers
     // off the main thread to avoid UI freezes during heavy native init.
@@ -43,7 +50,11 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
             recordingInterruptedEvent,
             deviceChangedEvent,
             trimProgressEvent,
-            errorEvent
+            errorEvent,
+            audioStreamChunkEvent,
+            audioStreamProgressEvent,
+            audioStreamCompleteEvent,
+            audioStreamErrorEvent
         ])
         
         OnCreate {
@@ -901,8 +912,141 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
                 }
             }
         }
+
+        AsyncFunction("streamAudioData") { (options: [String: Any], promise: Promise) in
+            guard let requestId = options["requestId"] as? String,
+                  let fileUri = options["fileUri"] as? String else {
+                promise.reject(
+                    "ERR_AUDIO_STREAM_INVALID_RANGE",
+                    "fileUri and requestId are required"
+                )
+                return
+            }
+
+            let streamFormat = options["streamFormat"] as? String ?? "float32"
+            guard streamFormat == "float32" else {
+                promise.reject(
+                    "ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT",
+                    "Only streamFormat='float32' is supported"
+                )
+                return
+            }
+
+            let opts = AudioStreamDecoder.Options(
+                requestId: requestId,
+                fileUri: fileUri,
+                startTimeMs: options["startTimeMs"] as? Double,
+                endTimeMs: options["endTimeMs"] as? Double,
+                targetSampleRate: options["targetSampleRate"] as? Double
+                    ?? (options["sampleRate"] as? Double),
+                channels: options["channels"] as? Int,
+                normalizeAudio: options["normalizeAudio"] as? Bool ?? true,
+                chunkDurationMs: options["chunkDurationMs"] as? Int ?? 1000,
+                maxChunkBytes: options["maxChunkBytes"] as? Int,
+                maxBufferedChunks: options["maxBufferedChunks"] as? Int ?? 4
+            )
+
+            let decoder = AudioStreamDecoder(options: opts)
+            decoder.delegate = self
+            self.streamDecodersLock.lock()
+            if self.streamDecoders[requestId] != nil {
+                self.streamDecodersLock.unlock()
+                promise.reject(
+                    "ERR_AUDIO_STREAM_BUSY",
+                    "requestId already in use"
+                )
+                return
+            }
+            self.streamDecoders[requestId] = decoder
+            self.streamDecodersLock.unlock()
+            decoder.start()
+            promise.resolve(["requestId": requestId])
+        }
+
+        AsyncFunction("cancelStreamAudioData") { (requestId: String, promise: Promise) in
+            self.streamDecodersLock.lock()
+            let decoder = self.streamDecoders[requestId]
+            self.streamDecodersLock.unlock()
+            decoder?.cancel()
+            promise.resolve(["requestId": requestId, "cancelled": decoder != nil])
+        }
+
+        Function("acknowledgeStreamAudioChunk") { (requestId: String, chunkIndex: Int) in
+            self.streamDecodersLock.lock()
+            let decoder = self.streamDecoders[requestId]
+            self.streamDecodersLock.unlock()
+            decoder?.acknowledgeChunk(chunkIndex)
+        }
+
+        AsyncFunction("getAudioDecodeCapabilities") { (promise: Promise) in
+            promise.resolve([
+                "platform": "ios",
+                "supportedInputFormats": [
+                    "audio/wav",
+                    "audio/aac",
+                    "audio/mp4",
+                    "audio/mpeg",
+                    "audio/x-m4a",
+                    "audio/caf",
+                    "audio/aiff",
+                ],
+                "supportedOutputFormats": ["float32"],
+                "supportsCancellation": true,
+                "supportsBackpressure": true,
+                "supportsTimeRange": true,
+                "supportsTargetSampleRate": true,
+                "supportsChannelMixing": true,
+                "knownLimitations": [
+                    "Opus/WebM input depends on AVFoundation codec availability for the iOS version."
+                ],
+            ])
+        }
     }
-    
+
+    private func releaseStreamDecoder(_ requestId: String) {
+        streamDecodersLock.lock()
+        streamDecoders.removeValue(forKey: requestId)
+        streamDecodersLock.unlock()
+    }
+
+    // MARK: - AudioStreamDecoderDelegate
+
+    public func streamDecoder(
+        _ decoder: AudioStreamDecoder,
+        didEmitChunk payload: [String: Any]
+    ) {
+        sendEvent(audioStreamChunkEvent, payload)
+    }
+
+    public func streamDecoder(
+        _ decoder: AudioStreamDecoder,
+        didReportProgress payload: [String: Any]
+    ) {
+        sendEvent(audioStreamProgressEvent, payload)
+    }
+
+    public func streamDecoder(
+        _ decoder: AudioStreamDecoder,
+        didCompleteWith payload: [String: Any]
+    ) {
+        if let requestId = payload["requestId"] as? String {
+            releaseStreamDecoder(requestId)
+        }
+        sendEvent(audioStreamCompleteEvent, payload)
+    }
+
+    public func streamDecoder(
+        _ decoder: AudioStreamDecoder,
+        didFailWith payload: [String: Any]
+    ) {
+        if let requestId = payload["requestId"] as? String,
+           let code = payload["code"] as? String,
+           code != "ERR_AUDIO_STREAM_CANCELLED" {
+            releaseStreamDecoder(requestId)
+        }
+        sendEvent(audioStreamErrorEvent, payload)
+    }
+
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any]) {
         Logger.debug("AudioStudioModule", "Delegate: didReceiveInterruption: \(info)")
         // Convert iOS interruption events to match the TypeScript types

package/ios/AudioStudioTests/AudioStreamDecoderTests.swift

@@ -0,0 +1,128 @@
+import XCTest
+@testable import AudioStudio
+
+final class AudioStreamDecoderTests: XCTestCase {
+
+    // MARK: - Sample sanitization
+
+    func testSafeFloatToInt16ReplacesNonFinite() {
+        XCTAssertEqual(safeFloatToInt16(Float.nan), 0)
+        XCTAssertEqual(safeFloatToInt16(Float.infinity), Int16.max)
+        XCTAssertEqual(safeFloatToInt16(-Float.infinity), Int16.min)
+    }
+
+    func testSafeFloatToInt16ClampsOutOfRange() {
+        XCTAssertEqual(safeFloatToInt16(2.0), Int16.max)
+        XCTAssertEqual(safeFloatToInt16(-2.0), Int16.min)
+        XCTAssertEqual(safeFloatToInt16(0.0), 0)
+    }
+
+    func testSafeFloatToInt16IdentityAtUnityIsBounded() {
+        // The previous Swift `Int16(1.0 * Float(Int16.max))` trap requires
+        // the result of the multiplication to fit Int16. The new helper
+        // must produce Int16.max for sample == 1.0 without trapping.
+        XCTAssertEqual(safeFloatToInt16(1.0), Int16.max)
+        XCTAssertEqual(safeFloatToInt16(-1.0), -Int16.max)
+    }
+
+    func testSafeFloatToInt32ReplacesNonFinite() {
+        XCTAssertEqual(safeFloatToInt32(Float.nan), 0)
+        XCTAssertEqual(safeFloatToInt32(Float.infinity), Int32.max)
+        XCTAssertEqual(safeFloatToInt32(-Float.infinity), Int32.min)
+    }
+
+    func testSafeFloatToInt32ClampsOutOfRange() {
+        XCTAssertEqual(safeFloatToInt32(5.0), Int32.max)
+        XCTAssertEqual(safeFloatToInt32(-5.0), Int32.min)
+    }
+
+    // MARK: - Decoder option bounds
+
+    func testDecoderOptionsClampsChunkDuration() {
+        let opts = AudioStreamDecoder.Options(
+            requestId: "test",
+            fileUri: "/dev/null",
+            startTimeMs: nil,
+            endTimeMs: nil,
+            targetSampleRate: nil,
+            channels: nil,
+            normalizeAudio: true,
+            chunkDurationMs: 5,
+            maxChunkBytes: nil,
+            maxBufferedChunks: 0
+        )
+        XCTAssertEqual(opts.chunkDurationMs, 10, "chunkDurationMs floor is 10ms")
+        XCTAssertEqual(opts.maxBufferedChunks, 1, "maxBufferedChunks floor is 1")
+
+        let bigOpts = AudioStreamDecoder.Options(
+            requestId: "big",
+            fileUri: "/dev/null",
+            startTimeMs: nil,
+            endTimeMs: nil,
+            targetSampleRate: nil,
+            channels: nil,
+            normalizeAudio: true,
+            chunkDurationMs: 999_999,
+            maxChunkBytes: nil,
+            maxBufferedChunks: 99
+        )
+        XCTAssertEqual(bigOpts.chunkDurationMs, 60_000, "chunkDurationMs ceiling is 60s")
+    }
+
+    // MARK: - Decoder event contract
+
+    final class CaptureDelegate: AudioStreamDecoderDelegate {
+        var chunks: [[String: Any]] = []
+        var progressEvents: [[String: Any]] = []
+        var completePayload: [String: Any]?
+        var errorPayload: [String: Any]?
+        let done = XCTestExpectation(description: "decoder terminal event")
+
+        func streamDecoder(_ decoder: AudioStreamDecoder, didEmitChunk payload: [String: Any]) {
+            chunks.append(payload)
+            if let idx = payload["chunkIndex"] as? Int {
+                decoder.acknowledgeChunk(idx)
+            }
+        }
+        func streamDecoder(_ decoder: AudioStreamDecoder, didReportProgress payload: [String: Any]) {
+            progressEvents.append(payload)
+        }
+        func streamDecoder(_ decoder: AudioStreamDecoder, didCompleteWith payload: [String: Any]) {
+            completePayload = payload
+            done.fulfill()
+        }
+        func streamDecoder(_ decoder: AudioStreamDecoder, didFailWith payload: [String: Any]) {
+            errorPayload = payload
+            // Some flows emit an error then a complete; let complete fulfill.
+        }
+    }
+
+    func testDecoderEmitsFileNotFoundForMissingPath() {
+        let delegate = CaptureDelegate()
+        let opts = AudioStreamDecoder.Options(
+            requestId: "missing",
+            fileUri: "/tmp/this-file-does-not-exist-\(UUID().uuidString).wav",
+            startTimeMs: nil,
+            endTimeMs: nil,
+            targetSampleRate: nil,
+            channels: nil,
+            normalizeAudio: true,
+            chunkDurationMs: 100,
+            maxChunkBytes: nil,
+            maxBufferedChunks: 2
+        )
+        let decoder = AudioStreamDecoder(options: opts)
+        decoder.delegate = delegate
+        decoder.start()
+        // Error path never calls complete, so wait directly on the error.
+        let exp = XCTestExpectation(description: "error received")
+        DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+            if delegate.errorPayload != nil {
+                exp.fulfill()
+            }
+        }
+        wait(for: [exp], timeout: 2.0)
+        XCTAssertEqual(delegate.errorPayload?["code"] as? String, "ERR_AUDIO_STREAM_FILE_NOT_FOUND")
+        XCTAssertEqual(delegate.errorPayload?["requestId"] as? String, "missing")
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/audio-studio",
-    "version": "3.1.1",
+    "version": "3.2.0-beta.1",
     "description": "Comprehensive audio processing library for React Native and Expo with recording, analysis, visualization, and streaming capabilities across iOS, Android, and web",
     "license": "MIT",
     "type": "commonjs",

package/src/errors/AudioStreamError.test.ts

@@ -0,0 +1,65 @@
+import { AudioStreamError, mapStreamError } from './AudioStreamError'
+
+describe('AudioStreamError', () => {
+    it('passes through an existing AudioStreamError unchanged', () => {
+        const original = new AudioStreamError({
+            code: 'ERR_AUDIO_STREAM_CANCELLED',
+            message: 'aborted',
+            recoverable: true,
+        })
+        expect(mapStreamError(original)).toBe(original)
+    })
+
+    it('maps native FILE_NOT_FOUND code', () => {
+        const mapped = mapStreamError({ code: 'FILE_NOT_FOUND', message: 'gone' })
+        expect(mapped.code).toBe('ERR_AUDIO_STREAM_FILE_NOT_FOUND')
+        expect(mapped.recoverable).toBe(false)
+    })
+
+    it('maps unsupported codec text', () => {
+        const mapped = mapStreamError(new Error('No suitable codec for audio/opus'))
+        expect(mapped.code).toBe('ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT')
+    })
+
+    it('marks cancellation as recoverable', () => {
+        const mapped = mapStreamError({
+            code: 'ERR_AUDIO_STREAM_CANCELLED',
+            message: 'user cancelled',
+        })
+        expect(mapped.code).toBe('ERR_AUDIO_STREAM_CANCELLED')
+        expect(mapped.recoverable).toBe(true)
+    })
+
+    it('falls back to UNKNOWN', () => {
+        const mapped = mapStreamError({})
+        expect(mapped.code).toBe('ERR_AUDIO_STREAM_UNKNOWN')
+    })
+
+    it('preserves nativeCode and nativeMessage', () => {
+        const mapped = mapStreamError({
+            code: 'WEIRD_NATIVE_CODE',
+            message: 'something went wrong on the bridge',
+        })
+        expect(mapped.nativeCode).toBe('WEIRD_NATIVE_CODE')
+        expect(mapped.nativeMessage).toContain('bridge')
+    })
+
+    it('serialises to a stable JSON payload', () => {
+        const err = new AudioStreamError({
+            code: 'ERR_AUDIO_STREAM_DECODE_FAILED',
+            message: 'decoder bust',
+            recoverable: false,
+            fileUri: 'file:///a.m4a',
+            platform: 'ios',
+        })
+        expect(err.toJSON()).toEqual({
+            code: 'ERR_AUDIO_STREAM_DECODE_FAILED',
+            message: 'decoder bust',
+            recoverable: false,
+            fileUri: 'file:///a.m4a',
+            platform: 'ios',
+            nativeCode: undefined,
+            nativeMessage: undefined,
+        })
+    })
+})

package/src/errors/AudioStreamError.ts

@@ -0,0 +1,185 @@
+/**
+ * Stable typed errors for `streamAudioData`. Callers can switch on `code`.
+ */
+export type AudioStreamErrorCode =
+    | 'ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT'
+    | 'ERR_AUDIO_STREAM_INVALID_RANGE'
+    | 'ERR_AUDIO_STREAM_DECODE_FAILED'
+    | 'ERR_AUDIO_STREAM_CANCELLED'
+    | 'ERR_AUDIO_STREAM_PERMISSION_DENIED'
+    | 'ERR_AUDIO_STREAM_FILE_NOT_FOUND'
+    | 'ERR_AUDIO_STREAM_BACKPRESSURE_TIMEOUT'
+    | 'ERR_AUDIO_STREAM_NATIVE_UNAVAILABLE'
+    | 'ERR_AUDIO_STREAM_BUSY'
+    | 'ERR_AUDIO_STREAM_UNKNOWN'
+
+export interface AudioStreamErrorPayload {
+    code: AudioStreamErrorCode
+    message: string
+    recoverable: boolean
+    fileUri?: string
+    platform?: string
+    nativeCode?: string
+    nativeMessage?: string
+}
+
+const RECOVERABLE: AudioStreamErrorCode[] = [
+    'ERR_AUDIO_STREAM_CANCELLED',
+    'ERR_AUDIO_STREAM_BUSY',
+    'ERR_AUDIO_STREAM_BACKPRESSURE_TIMEOUT',
+    'ERR_AUDIO_STREAM_PERMISSION_DENIED',
+]
+
+export class AudioStreamError extends Error {
+    readonly code: AudioStreamErrorCode
+    readonly recoverable: boolean
+    readonly fileUri?: string
+    readonly platform?: string
+    readonly nativeCode?: string
+    readonly nativeMessage?: string
+
+    constructor(payload: AudioStreamErrorPayload) {
+        super(payload.message)
+        this.name = 'AudioStreamError'
+        this.code = payload.code
+        this.recoverable = payload.recoverable
+        this.fileUri = payload.fileUri
+        this.platform = payload.platform
+        this.nativeCode = payload.nativeCode
+        this.nativeMessage = payload.nativeMessage
+    }
+
+    toJSON(): AudioStreamErrorPayload {
+        return {
+            code: this.code,
+            message: this.message,
+            recoverable: this.recoverable,
+            fileUri: this.fileUri,
+            platform: this.platform,
+            nativeCode: this.nativeCode,
+            nativeMessage: this.nativeMessage,
+        }
+    }
+}
+
+function getNativeMessage(err: unknown): string {
+    if (err instanceof Error) return err.message
+    if (typeof err === 'string') return err
+    try {
+        return JSON.stringify(err) ?? String(err)
+    } catch {
+        return String(err)
+    }
+}
+
+function getNativeCode(err: unknown): string | undefined {
+    if (err && typeof err === 'object' && 'code' in err) {
+        const code = (err as { code?: unknown }).code
+        if (typeof code === 'string') return code
+    }
+    return undefined
+}
+
+function normalizeCode(raw: string | undefined): AudioStreamErrorCode | null {
+    if (!raw) return null
+    const upper = raw.toUpperCase()
+    if (upper.startsWith('ERR_AUDIO_STREAM_')) {
+        const known: AudioStreamErrorCode[] = [
+            'ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT',
+            'ERR_AUDIO_STREAM_INVALID_RANGE',
+            'ERR_AUDIO_STREAM_DECODE_FAILED',
+            'ERR_AUDIO_STREAM_CANCELLED',
+            'ERR_AUDIO_STREAM_PERMISSION_DENIED',
+            'ERR_AUDIO_STREAM_FILE_NOT_FOUND',
+            'ERR_AUDIO_STREAM_BACKPRESSURE_TIMEOUT',
+            'ERR_AUDIO_STREAM_NATIVE_UNAVAILABLE',
+            'ERR_AUDIO_STREAM_BUSY',
+            'ERR_AUDIO_STREAM_UNKNOWN',
+        ]
+        if ((known as string[]).includes(upper)) {
+            return upper as AudioStreamErrorCode
+        }
+    }
+    if (upper.includes('FILE_NOT_FOUND') || upper === 'ENOENT') {
+        return 'ERR_AUDIO_STREAM_FILE_NOT_FOUND'
+    }
+    if (upper.includes('PERMISSION') || upper === 'EACCES') {
+        return 'ERR_AUDIO_STREAM_PERMISSION_DENIED'
+    }
+    if (
+        upper.includes('UNSUPPORTED') ||
+        upper.includes('NO_SUITABLE_CODEC') ||
+        upper.includes('NO SUITABLE CODEC') ||
+        upper.includes('NOT SUPPORTED')
+    ) {
+        return 'ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT'
+    }
+    if (
+        upper.includes('INVALID_RANGE') ||
+        upper.includes('OUT_OF_RANGE') ||
+        upper.includes('INVALID_TIME')
+    ) {
+        return 'ERR_AUDIO_STREAM_INVALID_RANGE'
+    }
+    if (upper.includes('CANCELLED') || upper.includes('CANCELED')) {
+        return 'ERR_AUDIO_STREAM_CANCELLED'
+    }
+    if (upper.includes('BUSY')) {
+        return 'ERR_AUDIO_STREAM_BUSY'
+    }
+    if (upper.includes('BACKPRESSURE')) {
+        return 'ERR_AUDIO_STREAM_BACKPRESSURE_TIMEOUT'
+    }
+    if (
+        upper.includes('DECODE') ||
+        upper.includes('CODEC') ||
+        upper.includes('MALFORMED')
+    ) {
+        return 'ERR_AUDIO_STREAM_DECODE_FAILED'
+    }
+    return null
+}
+
+export function mapStreamError(
+    err: unknown,
+    fileUri?: string,
+    platform?: string
+): AudioStreamError {
+    if (err instanceof AudioStreamError) return err
+
+    const nativeMessage = getNativeMessage(err)
+    const nativeCode = getNativeCode(err)
+    const lower = nativeMessage.toLowerCase()
+
+    let code =
+        normalizeCode(nativeCode) ??
+        normalizeCode(nativeMessage) ??
+        'ERR_AUDIO_STREAM_UNKNOWN'
+
+    if (code === 'ERR_AUDIO_STREAM_UNKNOWN') {
+        if (lower.includes('not found') || lower.includes('does not exist')) {
+            code = 'ERR_AUDIO_STREAM_FILE_NOT_FOUND'
+        } else if (
+            lower.includes('unsupported') ||
+            lower.includes('no suitable codec')
+        ) {
+            code = 'ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT'
+        } else if (lower.includes('permission') || lower.includes('denied')) {
+            code = 'ERR_AUDIO_STREAM_PERMISSION_DENIED'
+        } else if (lower.includes('decode') || lower.includes('codec')) {
+            code = 'ERR_AUDIO_STREAM_DECODE_FAILED'
+        } else if (lower.includes('cancel')) {
+            code = 'ERR_AUDIO_STREAM_CANCELLED'
+        }
+    }
+
+    return new AudioStreamError({
+        code,
+        message: `Audio stream failed (${code}): ${nativeMessage}`,
+        recoverable: RECOVERABLE.includes(code),
+        fileUri,
+        platform,
+        nativeCode,
+        nativeMessage,
+    })
+}

package/src/index.ts

@@ -19,6 +19,10 @@ import {
     useSharedAudioRecorder,
 } from './AudioRecorder.provider'
 import AudioStudioModule from './AudioStudioModule'
+import {
+    getAudioDecodeCapabilities,
+    streamAudioData,
+} from './streamAudioData'
 import { trimAudio } from './trimAudio'
 import { useAudioRecorder } from './useAudioRecorder'
 
@@ -54,6 +58,8 @@ export {
     extractPreview,
     trimAudio,
     extractAudioData,
+    streamAudioData,
+    getAudioDecodeCapabilities,
     extractMelSpectrogram,
     initMelStreamingWasm,
     computeMelFrameWasm,
@@ -71,6 +77,24 @@ export type {
     AudioExtractionErrorPayload,
 } from './errors/AudioExtractionError'
 
+export {
+    AudioStreamError,
+    mapStreamError,
+} from './errors/AudioStreamError'
+export type {
+    AudioStreamErrorCode,
+    AudioStreamErrorPayload,
+} from './errors/AudioStreamError'
+
+export type {
+    StreamAudioDataOptions,
+    StreamAudioDataChunk,
+    StreamAudioDataProgress,
+    StreamAudioDataResult,
+    StreamAudioDataCallbacks,
+    AudioDecodeCapabilities,
+} from './streamAudioData'
+
 // Export all types
 export type * from './AudioAnalysis/AudioAnalysis.types'
 export type * from './AudioStudio.types'