@siteed/expo-audio-studio 2.18.5 → 3.0.0

package/src/WebRecorder.web.ts

@@ -1,1005 +0,0 @@
-// packages/expo-audio-stream/src/WebRecorder.web.ts
-
-import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
-import { ConsoleLike, RecordingConfig } from './ExpoAudioStream.types'
-import {
-    EmitAudioAnalysisFunction,
-    EmitAudioEventFunction,
-} from './ExpoAudioStream.web'
-import { encodingToBitDepth } from './utils/encodingToBitDepth'
-import { writeWavHeader } from './utils/writeWavHeader'
-import { InlineFeaturesExtractor } from './workers/InlineFeaturesExtractor.web'
-import { InlineAudioWebWorker } from './workers/inlineAudioWebWorker.web'
-
-interface AudioWorkletEvent {
-    data: {
-        command: string
-        recordedData?: Float32Array
-        sampleRate?: number
-        position?: number
-        message?: string // For debug messages
-    }
-}
-
-interface AudioFeaturesEvent {
-    data: {
-        command: string
-        result: AudioAnalysis
-    }
-}
-
-const DEFAULT_WEB_BITDEPTH = 32
-const DEFAULT_SEGMENT_DURATION_MS = 100
-const DEFAULT_WEB_INTERVAL = 500
-const DEFAULT_WEB_NUMBER_OF_CHANNELS = 1
-
-const TAG = 'WebRecorder'
-
-export class WebRecorder {
-    public audioContext: AudioContext
-    private audioWorkletNode!: AudioWorkletNode
-    private featureExtractorWorker?: Worker
-    private source: MediaStreamAudioSourceNode
-    private emitAudioEventCallback: EmitAudioEventFunction
-    private emitAudioAnalysisCallback: EmitAudioAnalysisFunction
-    private config: RecordingConfig
-    private position: number = 0
-    private numberOfChannels: number // Number of audio channels
-    private bitDepth: number // Bit depth of the audio
-    private exportBitDepth: number // Bit depth of the audio
-    private audioAnalysisData: AudioAnalysis // Keep updating the full audio analysis data with latest events
-    private readonly logger?: ConsoleLike
-    private compressedMediaRecorder: MediaRecorder | null = null
-    private compressedChunks: Blob[] = []
-    private compressedSize: number = 0
-    private pendingCompressedChunk: Blob | null = null
-    private dataPointIdCounter: number = 0 // Add this property to track the counter
-    private deviceDisconnectionHandler: (() => void) | null = null
-    private readonly mediaStream: MediaStream | null = null
-    private readonly onInterruptionCallback?: (event: {
-        reason: string
-        isPaused: boolean
-        timestamp: number
-    }) => void
-    private _isDeviceDisconnected: boolean = false
-    private pcmData: Float32Array | null = null // Store original PCM data
-    private totalSampleCount: number = 0
-
-    /**
-     * Flag to indicate whether this is the first audio chunk after a device switch
-     * Used to maintain proper duration counting
-     */
-    public isFirstChunkAfterSwitch: boolean = false
-
-    /**
-     * Gets whether the recording device has been disconnected
-     */
-    get isDeviceDisconnected(): boolean {
-        return this._isDeviceDisconnected
-    }
-
-    /**
-     * Initializes a new WebRecorder instance for audio recording and processing
-     * @param audioContext - The AudioContext to use for recording
-     * @param source - The MediaStreamAudioSourceNode providing the audio input
-     * @param recordingConfig - Configuration options for the recording
-     * @param emitAudioEventCallback - Callback function for audio data events
-     * @param emitAudioAnalysisCallback - Callback function for audio analysis events
-     * @param onInterruption - Callback for recording interruptions
-     * @param logger - Optional logger for debugging information
-     */
-    constructor({
-        audioContext,
-        source,
-        recordingConfig,
-        emitAudioEventCallback,
-        emitAudioAnalysisCallback,
-        onInterruption,
-        logger,
-    }: {
-        audioContext: AudioContext
-        source: MediaStreamAudioSourceNode
-        recordingConfig: RecordingConfig
-        emitAudioEventCallback: EmitAudioEventFunction
-        emitAudioAnalysisCallback: EmitAudioAnalysisFunction
-        onInterruption?: (event: {
-            reason: string
-            isPaused: boolean
-            timestamp: number
-        }) => void
-        logger?: ConsoleLike
-    }) {
-        this.audioContext = audioContext
-        this.source = source
-        this.emitAudioEventCallback = emitAudioEventCallback
-        this.emitAudioAnalysisCallback = emitAudioAnalysisCallback
-        this.config = recordingConfig
-        this.logger = logger
-
-        const audioContextFormat = this.checkAudioContextFormat({
-            sampleRate: this.audioContext.sampleRate,
-        })
-        this.logger?.debug('Initialized WebRecorder with config:', {
-            sampleRate: audioContextFormat.sampleRate,
-            bitDepth: audioContextFormat.bitDepth,
-            numberOfChannels: audioContextFormat.numberOfChannels,
-        })
-
-        this.bitDepth = audioContextFormat.bitDepth
-        this.numberOfChannels =
-            audioContextFormat.numberOfChannels ||
-            DEFAULT_WEB_NUMBER_OF_CHANNELS // Default to 1 if not available
-        this.exportBitDepth =
-            encodingToBitDepth({
-                encoding: recordingConfig.encoding ?? 'pcm_32bit',
-            }) ||
-            audioContextFormat.bitDepth ||
-            DEFAULT_WEB_BITDEPTH
-
-        this.audioAnalysisData = {
-            amplitudeRange: { min: 0, max: 0 },
-            rmsRange: { min: 0, max: 0 },
-            dataPoints: [],
-            durationMs: 0,
-            samples: 0,
-            bitDepth: this.bitDepth,
-            numberOfChannels: this.numberOfChannels,
-            sampleRate: this.config.sampleRate || this.audioContext.sampleRate,
-            segmentDurationMs:
-                this.config.segmentDurationMs ?? DEFAULT_SEGMENT_DURATION_MS, // Default to 100ms segments
-            extractionTimeMs: 0,
-        }
-
-        if (recordingConfig.enableProcessing) {
-            this.initFeatureExtractorWorker()
-        }
-
-        // Initialize compressed recording if enabled
-        if (recordingConfig.output?.compressed?.enabled) {
-            this.initializeCompressedRecorder()
-        }
-
-        this.mediaStream = source.mediaStream
-        this.onInterruptionCallback = onInterruption
-
-        // Setup device disconnection detection
-        this.setupDeviceDisconnectionDetection()
-    }
-
-    /**
-     * Initializes the audio worklet using an inline script
-     * Creates and connects the audio processing pipeline
-     */
-    async init() {
-        try {
-            // Create and use inline audio worklet
-            const blob = new Blob([InlineAudioWebWorker], {
-                type: 'application/javascript',
-            })
-            const url = URL.createObjectURL(blob)
-            await this.audioContext.audioWorklet.addModule(url)
-
-            this.audioWorkletNode = new AudioWorkletNode(
-                this.audioContext,
-                'recorder-processor'
-            )
-
-            this.audioWorkletNode.port.onmessage = async (
-                event: AudioWorkletEvent
-            ) => {
-                const command = event.data.command
-                if (command === 'debug') {
-                    this.logger?.debug(`[AudioWorklet] ${event.data.message}`)
-                    return
-                }
-
-                if (command !== 'newData') return
-
-                const pcmBufferFloat = event.data.recordedData
-                if (!pcmBufferFloat) {
-                    this.logger?.warn('Received empty audio buffer', event)
-                    return
-                }
-
-                // Process data in smaller chunks and emit immediately
-                const sampleRate =
-                    event.data.sampleRate ?? this.audioContext.sampleRate
-                // Use chunk size from config interval or default to 2 seconds
-                const intervalMs = this.config.interval ?? DEFAULT_WEB_INTERVAL
-                const chunkSize = Math.floor(sampleRate * (intervalMs / 1000))
-                const duration = pcmBufferFloat.length / sampleRate
-
-                // Use incoming position if provided by worklet, otherwise use our tracked position
-                const incomingPosition =
-                    typeof event.data.position === 'number'
-                        ? event.data.position
-                        : this.position
-
-                // Simple position tracking for logging (no duplicate filtering)
-                this.logger?.debug(
-                    `Audio chunk: position=${incomingPosition.toFixed(3)}s, size=${pcmBufferFloat.length}`
-                )
-
-                // Calculate bytes per sample based on bit depth
-                const bytesPerSample = this.bitDepth / 8
-
-                // Emit chunks without storing them
-                for (let i = 0; i < pcmBufferFloat.length; i += chunkSize) {
-                    const chunk = pcmBufferFloat.slice(i, i + chunkSize)
-                    const chunkPosition = incomingPosition + i / sampleRate
-
-                    // Calculate byte positions and samples
-                    const startPosition = Math.floor(i * bytesPerSample)
-                    const endPosition = Math.floor(
-                        (i + chunk.length) * bytesPerSample
-                    )
-                    const samples = chunk.length // Number of samples in this chunk
-
-                    // Only store PCM data if primary output is enabled
-                    const shouldStoreUncompressed =
-                        this.config.output?.primary?.enabled ?? true
-
-                    // Store PCM chunks when needed - this is for the final WAV file
-                    if (shouldStoreUncompressed) {
-                        // Store the original Float32Array data for later WAV creation
-                        this.appendPcmData(chunk)
-                        this.totalSampleCount += chunk.length
-                    }
-
-                    // Process features if enabled
-                    if (
-                        this.config.enableProcessing &&
-                        this.featureExtractorWorker
-                    ) {
-                        this.featureExtractorWorker.postMessage({
-                            command: 'process',
-                            channelData: chunk,
-                            sampleRate,
-                            segmentDurationMs:
-                                this.config.segmentDurationMs ??
-                                DEFAULT_SEGMENT_DURATION_MS, // Default to 100ms
-                            bitDepth: this.bitDepth,
-                            fullAudioDurationMs: chunkPosition * 1000,
-                            numberOfChannels: this.numberOfChannels,
-                            features: this.config.features,
-                            intervalAnalysis: this.config.intervalAnalysis,
-                            startPosition,
-                            endPosition,
-                            samples,
-                        })
-                    }
-
-                    // Prepare compression data if available
-                    const compression = this.pendingCompressedChunk
-                        ? {
-                              data: this.pendingCompressedChunk,
-                              size: this.pendingCompressedChunk.size,
-                              totalSize: this.compressedSize,
-                              mimeType: 'audio/webm',
-                              format:
-                                  this.config.output?.compressed?.format ??
-                                  'opus',
-                              bitrate:
-                                  this.config.output?.compressed?.bitrate ??
-                                  128000,
-                          }
-                        : undefined
-
-                    // Emit chunk immediately - whether compressed or not
-                    this.emitAudioEventCallback({
-                        data: chunk,
-                        position: chunkPosition,
-                        compression,
-                    })
-
-                    // Reset pending compressed chunk after we've used it
-                    this.pendingCompressedChunk = null
-                }
-
-                // Update our position based on the worklet's position if provided
-                this.position = incomingPosition + duration
-            }
-
-            // Ensure we use all relevant settings from config
-            const recordSampleRate = this.audioContext.sampleRate
-            const exportSampleRate =
-                this.config.sampleRate ?? this.audioContext.sampleRate
-            const channels = this.config.channels ?? this.numberOfChannels
-            const interval = this.config.interval ?? DEFAULT_WEB_INTERVAL
-
-            this.logger?.debug(`WebRecorder initialized with config:`, {
-                recordSampleRate,
-                exportSampleRate,
-                bitDepth: this.bitDepth,
-                exportBitDepth: this.exportBitDepth,
-                channels,
-                interval,
-                position: this.position,
-                deviceId: this.config.deviceId ?? 'default',
-                compression: this.config.output?.compressed
-                    ? {
-                          enabled: this.config.output.compressed.enabled,
-                          format: this.config.output.compressed.format,
-                          bitrate: this.config.output.compressed.bitrate,
-                      }
-                    : 'disabled',
-            })
-
-            // Initialize the worklet with all settings from config
-            this.audioWorkletNode.port.postMessage({
-                command: 'init',
-                recordSampleRate,
-                exportSampleRate,
-                bitDepth: this.bitDepth,
-                exportBitDepth: this.exportBitDepth,
-                channels,
-                interval,
-                position: this.position, // Pass the current position to the processor
-                enableLogging: true,
-            })
-
-            // Connect the source to the AudioWorkletNode and start recording
-            this.source.connect(this.audioWorkletNode)
-            this.audioWorkletNode.connect(this.audioContext.destination)
-        } catch (error) {
-            console.error(`[${TAG}] Failed to initialize WebRecorder`, error)
-        }
-    }
-
-    /**
-     * Append new PCM data to the existing buffer
-     * @param newData New Float32Array data to append
-     */
-    private appendPcmData(newData: Float32Array): void {
-        // Clone the incoming data to ensure it's not modified
-        const dataToAdd = new Float32Array(newData)
-
-        if (!this.pcmData) {
-            // First chunk - create a copy to avoid references to original data
-            this.pcmData = new Float32Array(dataToAdd)
-            return
-        }
-
-        // Create a new buffer with increased size
-        const newBuffer = new Float32Array(
-            this.pcmData.length + dataToAdd.length
-        )
-
-        // Copy existing data
-        newBuffer.set(this.pcmData)
-
-        // Append new data
-        newBuffer.set(dataToAdd, this.pcmData.length)
-
-        // Replace existing buffer
-        this.pcmData = newBuffer
-    }
-
-    /**
-     * Initializes the feature extractor worker for audio analysis
-     * Creates an inline worker from a blob for audio feature extraction
-     */
-    initFeatureExtractorWorker() {
-        try {
-            const blob = new Blob([InlineFeaturesExtractor], {
-                type: 'application/javascript',
-            })
-            const url = URL.createObjectURL(blob)
-            this.featureExtractorWorker = new Worker(url)
-            this.featureExtractorWorker.onmessage =
-                this.handleFeatureExtractorMessage.bind(this)
-            this.featureExtractorWorker.onerror = (error) => {
-                console.error(`[${TAG}] Feature extractor worker error:`, error)
-            }
-
-            // Initialize worker with counter if needed
-            if (this.dataPointIdCounter > 0) {
-                this.featureExtractorWorker.postMessage({
-                    command: 'resetCounter',
-                    value: this.dataPointIdCounter,
-                })
-                this.logger?.debug(
-                    `Initialized worker with counter value ${this.dataPointIdCounter}`
-                )
-            }
-
-            this.logger?.log(
-                'Feature extractor worker initialized successfully'
-            )
-        } catch (error) {
-            console.error(
-                `[${TAG}] Failed to initialize feature extractor worker`,
-                error
-            )
-        }
-    }
-
-    /**
-     * Processes audio analysis results from the feature extractor worker
-     * Updates the audio analysis data and emits events
-     * @param event - The event containing audio analysis results
-     */
-    handleFeatureExtractorMessage(event: AudioFeaturesEvent) {
-        if (event.data.command !== 'features') return
-
-        const segmentResult = event.data.result
-        const uniqueNewDataPoints = this.filterUniqueDataPoints(
-            segmentResult.dataPoints
-        )
-
-        // Update counter based on the highest ID seen
-        this.updateDataPointCounter(uniqueNewDataPoints)
-
-        // Update analysis data with the new results
-        this.updateAudioAnalysisData(segmentResult, uniqueNewDataPoints)
-
-        // Send filtered result to avoid duplicate IDs
-        const filteredSegmentResult = {
-            ...segmentResult,
-            dataPoints: uniqueNewDataPoints,
-        }
-
-        this.emitAudioAnalysisCallback(filteredSegmentResult)
-    }
-
-    /**
-     * Filters out data points with duplicate IDs
-     */
-    private filterUniqueDataPoints(dataPoints: any[]): any[] {
-        // Track existing IDs to prevent duplicates
-        const existingIds = new Set(
-            this.audioAnalysisData.dataPoints.map((dp) => dp.id)
-        )
-
-        // Filter out datapoints with duplicate IDs
-        const uniquePoints = dataPoints.filter((dp) => !existingIds.has(dp.id))
-
-        // Log filtered duplicates if any
-        if (uniquePoints.length < dataPoints.length && this.logger?.warn) {
-            this.logger.warn(
-                `Filtered ${dataPoints.length - uniquePoints.length} duplicate datapoints`
-            )
-        }
-
-        return uniquePoints
-    }
-
-    /**
-     * Updates the counter based on the highest ID in datapoints
-     */
-    private updateDataPointCounter(dataPoints: any[]): void {
-        if (dataPoints.length === 0) return
-
-        const lastDataPoint = dataPoints[dataPoints.length - 1]
-        if (lastDataPoint && typeof lastDataPoint.id === 'number') {
-            const nextIdValue = lastDataPoint.id + 1
-            if (nextIdValue > this.dataPointIdCounter) {
-                this.dataPointIdCounter = nextIdValue
-                this.logger?.debug(
-                    `Counter updated to ${this.dataPointIdCounter}`
-                )
-            }
-        }
-    }
-
-    /**
-     * Updates audio analysis data with segment results
-     */
-    private updateAudioAnalysisData(
-        segmentResult: AudioAnalysis,
-        uniqueDataPoints: any[]
-    ): void {
-        // Add unique data points to our analysis data
-        this.audioAnalysisData.dataPoints.push(...uniqueDataPoints)
-        this.audioAnalysisData.durationMs += segmentResult.durationMs
-        this.audioAnalysisData.sampleRate = segmentResult.sampleRate
-
-        // Update amplitude range if present
-        if (segmentResult.amplitudeRange) {
-            this.audioAnalysisData.amplitudeRange = this.mergeRange(
-                this.audioAnalysisData.amplitudeRange,
-                segmentResult.amplitudeRange
-            )
-        }
-
-        // Update RMS range if present
-        if (segmentResult.rmsRange) {
-            this.audioAnalysisData.rmsRange = this.mergeRange(
-                this.audioAnalysisData.rmsRange,
-                segmentResult.rmsRange
-            )
-        }
-    }
-
-    /**
-     * Merges value ranges
-     */
-    private mergeRange(
-        existing: { min: number; max: number } | undefined,
-        newRange: { min: number; max: number }
-    ): { min: number; max: number } {
-        if (!existing) return { ...newRange }
-
-        return {
-            min: Math.min(existing.min, newRange.min),
-            max: Math.max(existing.max, newRange.max),
-        }
-    }
-
-    /**
-     * Reset the data point counter to a specific value or zero
-     * @param startCounterFrom Optional value to start the counter from (for continuing from previous recordings)
-     */
-    resetDataPointCounter(startCounterFrom?: number): void {
-        // Set the counter with the passed value or 0
-        this.dataPointIdCounter = startCounterFrom ?? 0
-        this.logger?.debug(
-            `Reset data point counter to ${this.dataPointIdCounter}`
-        )
-
-        // Update worker counter if available
-        if (this.featureExtractorWorker) {
-            this.featureExtractorWorker.postMessage({
-                command: 'resetCounter',
-                value: this.dataPointIdCounter,
-            })
-        } else {
-            this.logger?.warn(
-                'No feature extractor worker available to update counter'
-            )
-        }
-    }
-
-    /**
-     * Get the current data point counter value
-     * @returns The current value of the data point counter
-     */
-    getDataPointCounter(): number {
-        return this.dataPointIdCounter
-    }
-
-    /**
-     * Prepares the recorder for continuity after device switch
-     * Sets up all necessary state to maintain proper recording continuity
-     */
-    prepareForDeviceSwitch(): void {
-        this.isFirstChunkAfterSwitch = true
-        this.logger?.debug(
-            `Prepared for device switch at position ${this.position}s`
-        )
-    }
-
-    /**
-     * Starts the audio recording process
-     * Connects the audio nodes and begins capturing audio data
-     * @param preserveCounters If true, do not reset the counter (used for device switching)
-     */
-    start(preserveCounters = false) {
-        this.source.connect(this.audioWorkletNode)
-        this.audioWorkletNode.connect(this.audioContext.destination)
-
-        // Only reset the counter when not preserving state (e.g., for a fresh recording)
-        if (!preserveCounters) {
-            this.logger?.debug(
-                'Starting fresh recording, resetting counter to 0'
-            )
-            this.resetDataPointCounter(0) // Explicitly reset to 0 for new recordings
-            this.isFirstChunkAfterSwitch = false
-
-            // Clear PCM data for new recording
-            this.pcmData = null
-            this.totalSampleCount = 0
-        } else {
-            this.logger?.debug(
-                `Preserving counter at ${this.dataPointIdCounter} during device switch`
-            )
-        }
-
-        if (this.compressedMediaRecorder) {
-            this.compressedMediaRecorder.start(this.config.interval ?? 1000)
-        }
-    }
-
-    /**
-     * Creates a WAV file from the stored PCM data
-     */
-    private createWavFromPcmData(): Blob | null {
-        try {
-            // Check if we have PCM data
-            if (!this.pcmData || this.pcmData.length === 0) {
-                this.logger?.warn('No PCM data available to create WAV file')
-                return null
-            }
-
-            const sampleRate =
-                this.config.sampleRate ?? this.audioContext.sampleRate
-            const channels = this.numberOfChannels || 1
-
-            // Convert float32 PCM data to 16-bit PCM for WAV
-            const bytesPerSample = 2 // 16-bit = 2 bytes
-            const dataLength = this.pcmData.length * bytesPerSample
-            const buffer = new ArrayBuffer(dataLength)
-            const view = new DataView(buffer)
-
-            // Convert Float32Array (-1 to 1) to Int16Array (-32768 to 32767)
-            for (let i = 0; i < this.pcmData.length; i++) {
-                const sample = Math.max(-1, Math.min(1, this.pcmData[i]))
-                const int16Value = Math.round(sample * 32767)
-                view.setInt16(i * 2, int16Value, true)
-            }
-
-            // Use the existing writeWavHeader utility to add a WAV header
-            const wavBuffer = writeWavHeader({
-                buffer,
-                sampleRate,
-                numChannels: channels,
-                bitDepth: 16,
-                isFloat: false,
-            })
-
-            return new Blob([wavBuffer], { type: 'audio/wav' })
-        } catch (error) {
-            this.logger?.error('Error creating WAV file from PCM data:', error)
-            return null
-        }
-    }
-
-    /**
-     * Stops the audio recording process and returns the recorded data
-     * @returns Promise resolving to an object containing compressed and/or uncompressed blobs
-     */
-    async stop(): Promise<{ compressedBlob?: Blob; uncompressedBlob?: Blob }> {
-        try {
-            // Stop any compressed recording first
-            if (
-                this.compressedMediaRecorder &&
-                this.compressedMediaRecorder.state !== 'inactive'
-            ) {
-                this.compressedMediaRecorder.stop()
-            }
-
-            // Wait for any pending compressed chunks to be processed
-            if (this.compressedMediaRecorder) {
-                // Small delay to ensure all data is processed
-                await new Promise((resolve) => setTimeout(resolve, 100))
-            }
-
-            // Create uncompressed WAV file from the PCM data
-            let uncompressedBlob: Blob | undefined
-
-            // Only create WAV if we have PCM data
-            if (this.pcmData && this.pcmData.length > 0) {
-                uncompressedBlob = this.createWavFromPcmData() || undefined
-            }
-
-            // Return the compressed and/or uncompressed blobs if available
-            return {
-                compressedBlob:
-                    this.compressedChunks.length > 0
-                        ? new Blob(this.compressedChunks, {
-                              type: 'audio/webm;codecs=opus',
-                          })
-                        : undefined,
-                uncompressedBlob,
-            }
-        } finally {
-            this.cleanup()
-            // Reset the chunks array
-            this.compressedChunks = []
-            this.compressedSize = 0
-            this.pendingCompressedChunk = null
-            this.pcmData = null
-            this.totalSampleCount = 0
-            this.dataPointIdCounter = 0 // Reset counter
-        }
-    }
-
-    /**
-     * Cleans up resources when recording is stopped
-     * Closes audio context and disconnects nodes
-     */
-    public cleanup() {
-        // Remove device disconnection handler
-        if (this.deviceDisconnectionHandler) {
-            this.deviceDisconnectionHandler()
-            this.deviceDisconnectionHandler = null
-        }
-
-        // Check if AudioContext is already closed before attempting to close it
-        if (this.audioContext && this.audioContext.state !== 'closed') {
-            this.audioContext.close().catch((e) => {
-                // Log closure errors but continue cleanup
-                this.logger?.warn('Error closing AudioContext:', e)
-            })
-        }
-
-        // Safely disconnect audioWorkletNode if it exists
-        if (this.audioWorkletNode) {
-            try {
-                this.audioWorkletNode.disconnect()
-            } catch (e) {
-                // Log disconnection errors but continue cleanup
-                this.logger?.warn('Error disconnecting audioWorkletNode:', e)
-            }
-        }
-
-        // Safely disconnect source if it exists
-        if (this.source) {
-            try {
-                this.source.disconnect()
-            } catch (e) {
-                // Log disconnection errors but continue cleanup
-                this.logger?.warn('Error disconnecting source:', e)
-            }
-        }
-
-        // Always stop media stream tracks to release hardware resources
-        this.stopMediaStreamTracks()
-
-        // Mark as disconnected to prevent future errors
-        this._isDeviceDisconnected = true
-    }
-
-    /**
-     * Pauses the audio recording process
-     * Disconnects audio nodes and pauses the media recorder
-     */
-    pause() {
-        try {
-            // Note: We're just pausing, not disconnecting the device
-            // Simply disconnect nodes temporarily without marking device as disconnected
-            this.source.disconnect(this.audioWorkletNode)
-            this.audioWorkletNode.disconnect(this.audioContext.destination)
-            this.audioWorkletNode.port.postMessage({ command: 'pause' })
-
-            if (this.compressedMediaRecorder?.state === 'recording') {
-                this.compressedMediaRecorder.pause()
-            }
-
-            this.logger?.debug('Recording paused successfully')
-        } catch (error) {
-            this.logger?.error('Error in pause(): ', error)
-            // Already disconnected, just ignore and continue
-        }
-    }
-
-    /**
-     * Stops all media stream tracks to release hardware resources
-     * Ensures recording indicators (like microphone icon) are turned off
-     */
-    public stopMediaStreamTracks() {
-        // Stop all audio tracks to stop the recording icon
-        if (this.mediaStream) {
-            const tracks = this.mediaStream.getTracks()
-            tracks.forEach((track) => track.stop())
-        } else if (this.source?.mediaStream) {
-            const tracks = this.source.mediaStream.getTracks()
-            tracks.forEach((track) => track.stop())
-        }
-    }
-
-    /**
-     * Determines the audio format capabilities of the current audio context
-     * @param sampleRate - The sample rate to check
-     * @returns Object containing format information (sample rate, bit depth, channels)
-     */
-    private checkAudioContextFormat({ sampleRate }: { sampleRate: number }) {
-        // Create a silent AudioBuffer
-        const frameCount = sampleRate * 1.0 // 1 second buffer
-        const audioBuffer = this.audioContext.createBuffer(
-            1,
-            frameCount,
-            sampleRate
-        )
-
-        // Check the format
-        const channelData = audioBuffer.getChannelData(0)
-        const bitDepth = channelData.BYTES_PER_ELEMENT * 8 // 4 bytes per element means 32-bit
-
-        return {
-            sampleRate: audioBuffer.sampleRate,
-            bitDepth,
-            numberOfChannels: audioBuffer.numberOfChannels,
-        }
-    }
-
-    /**
-     * Resumes a paused recording
-     * Reconnects audio nodes and resumes the media recorder
-     */
-    resume() {
-        // If device was disconnected, we can't resume
-        if (this._isDeviceDisconnected) {
-            this.logger?.warn('Cannot resume recording: device disconnected')
-            return
-        }
-
-        try {
-            this.source.connect(this.audioWorkletNode)
-            this.audioWorkletNode.connect(this.audioContext.destination)
-            this.audioWorkletNode.port.postMessage({ command: 'resume' })
-            this.compressedMediaRecorder?.resume()
-        } catch (error: unknown) {
-            this.logger?.error('Error in resume(): ', error)
-            // Rethrow the error to inform callers
-            throw new Error(
-                `Failed to resume recording: ${error instanceof Error ? error.message : 'unknown error'}`
-            )
-        }
-    }
-
-    /**
-     * Initializes the compressed media recorder if compression is enabled
-     * Sets up event handlers for compressed audio data
-     */
-    private initializeCompressedRecorder() {
-        try {
-            const mimeType = 'audio/webm;codecs=opus'
-            if (!MediaRecorder.isTypeSupported(mimeType)) {
-                this.logger?.warn(
-                    'Opus compression not supported in this browser'
-                )
-                return
-            }
-
-            this.compressedMediaRecorder = new MediaRecorder(
-                this.source.mediaStream,
-                {
-                    mimeType,
-                    audioBitsPerSecond:
-                        this.config.output?.compressed?.bitrate ?? 128000,
-                }
-            )
-
-            this.compressedMediaRecorder.ondataavailable = (event) => {
-                if (event.data.size > 0) {
-                    // Store the compressed chunk for final blob creation
-                    this.compressedChunks.push(event.data)
-                    this.compressedSize += event.data.size
-
-                    // Store the pending compressed chunk for the next PCM chunk to use
-                    this.pendingCompressedChunk = event.data
-                }
-            }
-        } catch (error) {
-            this.logger?.error(
-                'Failed to initialize compressed recorder:',
-                error
-            )
-            // Setting to null to indicate initialization failed
-            this.compressedMediaRecorder = null
-        }
-    }
-
-    /**
-     * Processes features if enabled
-     */
-    processFeatures(
-        chunk: Float32Array,
-        sampleRate: number,
-        chunkPosition: number,
-        startPosition: number,
-        endPosition: number,
-        samples: number
-    ) {
-        if (this.config.enableProcessing && this.featureExtractorWorker) {
-            this.featureExtractorWorker.postMessage({
-                command: 'process',
-                channelData: chunk,
-                sampleRate,
-                segmentDurationMs:
-                    this.config.segmentDurationMs ??
-                    DEFAULT_SEGMENT_DURATION_MS, // Default to 100ms
-                bitDepth: this.bitDepth,
-                fullAudioDurationMs: chunkPosition * 1000,
-                numberOfChannels: this.numberOfChannels,
-                features: this.config.features,
-                intervalAnalysis: this.config.intervalAnalysis,
-                startPosition,
-                endPosition,
-                samples,
-            })
-        }
-    }
-
-    /**
-     * Sets up detection for device disconnection events
-     */
-    private setupDeviceDisconnectionDetection() {
-        if (!this.mediaStream) return
-
-        // Function to handle track ending (which happens on device disconnection)
-        const handleTrackEnded = () => {
-            this.logger?.warn('Audio track ended - device disconnected')
-            this._isDeviceDisconnected = true
-
-            // Use the callback to notify parent component about device disconnection
-            if (this.onInterruptionCallback) {
-                this.onInterruptionCallback({
-                    reason: 'deviceDisconnected',
-                    isPaused: true,
-                    timestamp: Date.now(),
-                })
-                this.logger?.debug('Notified about device disconnection')
-            }
-
-            // Ensure we disconnect nodes to prevent zombie recordings
-            if (this.audioWorkletNode) {
-                this.audioWorkletNode.port.postMessage({
-                    command: 'deviceDisconnected',
-                })
-
-                try {
-                    this.source.disconnect(this.audioWorkletNode)
-                    this.audioWorkletNode.disconnect()
-                } catch (e) {
-                    // Ignore disconnection errors as the track might already be gone
-                    this.logger?.warn(
-                        'Error disconnecting audioWorkletNode:',
-                        e
-                    )
-                }
-            }
-        }
-
-        // Add listeners to all audio tracks
-        const tracks = this.mediaStream.getAudioTracks()
-        tracks.forEach((track) => {
-            track.addEventListener('ended', handleTrackEnded)
-        })
-
-        // Store the handler for cleanup
-        this.deviceDisconnectionHandler = () => {
-            tracks.forEach((track) => {
-                track.removeEventListener('ended', handleTrackEnded)
-            })
-        }
-    }
-
-    /**
-     * Explicitly set the position for continuous recording across device switches
-     * @param position The position in seconds to continue from
-     */
-    setPosition(position: number): void {
-        if (position >= 0) {
-            this.position = position
-            this.logger?.debug(`Position explicitly set to ${position} seconds`)
-        } else {
-            this.logger?.warn(`Invalid position value: ${position}, ignoring`)
-        }
-    }
-
-    /**
-     * Get the current position in seconds
-     * @returns The current position
-     */
-    getPosition(): number {
-        return this.position
-    }
-
-    /**
-     * Gets the current compressed chunks
-     * @returns Array of current compressed audio chunks
-     */
-    getCompressedChunks(): Blob[] {
-        return [...this.compressedChunks]
-    }
-
-    /**
-     * Sets the compressed chunks from a previous recorder
-     * @param chunks Array of compressed chunks from a previous recorder
-     */
-    setCompressedChunks(chunks: Blob[]): void {
-        if (chunks && chunks.length > 0) {
-            this.logger?.debug(
-                `Adding ${chunks.length} compressed chunks from previous device`
-            )
-            this.compressedChunks = [...chunks, ...this.compressedChunks]
-            // Update size
-            this.compressedSize = this.compressedChunks.reduce(
-                (size, chunk) => size + chunk.size,
-                0
-            )
-        }
-    }
-}