@siteed/expo-audio-studio 2.4.1 → 2.5.0

package/build/WebRecorder.web.d.ts

@@ -8,7 +8,7 @@ interface AudioFeaturesEvent {
     };
 }
 export declare class WebRecorder {
-    private audioContext;
+    audioContext: AudioContext;
     private audioWorkletNode;
     private featureExtractorWorker?;
     private source;
@@ -20,14 +20,25 @@ export declare class WebRecorder {
     private bitDepth;
     private exportBitDepth;
     private audioAnalysisData;
-    private packetCount;
     private logger?;
     private compressedMediaRecorder;
     private compressedChunks;
     private compressedSize;
     private pendingCompressedChunk;
-    private readonly wavMimeType;
     private dataPointIdCounter;
+    private deviceDisconnectionHandler;
+    private mediaStream;
+    private onInterruptionCallback?;
+    private _isDeviceDisconnected;
+    /**
+     * Flag to indicate whether this is the first audio chunk after a device switch
+     * Used to maintain proper duration counting
+     */
+    isFirstChunkAfterSwitch: boolean;
+    /**
+     * Gets whether the recording device has been disconnected
+     */
+    get isDeviceDisconnected(): boolean;
     /**
      * Initializes a new WebRecorder instance for audio recording and processing
      * @param audioContext - The AudioContext to use for recording
@@ -35,14 +46,20 @@ export declare class WebRecorder {
      * @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, logger, }: {
+    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;
     });
     /**
@@ -62,20 +79,32 @@ export declare class WebRecorder {
      */
     handleFeatureExtractorMessage(event: AudioFeaturesEvent): void;
     /**
-     * Resets the data point ID counter
-     * Used when starting a new recording
+     * 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(): void;
+    resetDataPointCounter(startCounterFrom?: number): void;
+    /**
+     * Get the current data point counter value
+     * @returns The current value of the data point counter
+     */
+    getDataPointCounter(): number;
+    /**
+     * Prepares the recorder for continuity after device switch
+     * Sets up all necessary state to maintain proper recording continuity
+     */
+    prepareForDeviceSwitch(): void;
     /**
      * 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(): void;
+    start(preserveCounters?: boolean): void;
     /**
      * Stops the audio recording process and returns the recorded data
+     * @param externalAudioChunks Optional array of Float32Array chunks from previous devices
      * @returns Promise resolving to an object containing PCM data and optional compressed blob
      */
-    stop(): Promise<{
+    stop(externalAudioChunks?: Float32Array[]): Promise<{
         pcmData: Float32Array;
         compressedBlob?: Blob;
     }>;
@@ -83,7 +112,7 @@ export declare class WebRecorder {
      * Cleans up resources when recording is stopped
      * Closes audio context and disconnects nodes
      */
-    private cleanup;
+    cleanup(): void;
     /**
      * Pauses the audio recording process
      * Disconnects audio nodes and pauses the media recorder
@@ -114,6 +143,30 @@ export declare class WebRecorder {
      * Processes features if enabled
      */
     processFeatures(chunk: Float32Array, sampleRate: number, chunkPosition: number, startPosition: number, endPosition: number, samples: number): void;
+    /**
+     * Sets up detection for device disconnection events
+     */
+    private setupDeviceDisconnectionDetection;
+    /**
+     * Explicitly set the position for continuous recording across device switches
+     * @param position The position in seconds to continue from
+     */
+    setPosition(position: number): void;
+    /**
+     * Get the current position in seconds
+     * @returns The current position
+     */
+    getPosition(): number;
+    /**
+     * Gets the current compressed chunks
+     * @returns Array of current compressed audio chunks
+     */
+    getCompressedChunks(): Blob[];
+    /**
+     * Sets the compressed chunks from a previous recorder
+     * @param chunks Array of compressed chunks from a previous recorder
+     */
+    setCompressedChunks(chunks: Blob[]): void;
 }
 export {};
 //# sourceMappingURL=WebRecorder.web.d.ts.map

package/build/WebRecorder.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebRecorder.web.d.ts","sourceRoot":"","sources":["../src/WebRecorder.web.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAA;AACnE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACtE,OAAO,EACH,yBAAyB,EACzB,sBAAsB,EACzB,MAAM,uBAAuB,CAAA;AAa9B,UAAU,kBAAkB;IACxB,IAAI,EAAE;QACF,OAAO,EAAE,MAAM,CAAA;QACf,MAAM,EAAE,aAAa,CAAA;KACxB,CAAA;CACJ;AASD,qBAAa,WAAW;IACpB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,sBAAsB,CAAC,CAAQ;IACvC,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,sBAAsB,CAAwB;IACtD,OAAO,CAAC,yBAAyB,CAA2B;IAC5D,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,iBAAiB,CAAe;IACxC,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,MAAM,CAAC,CAAa;IAC5B,OAAO,CAAC,uBAAuB,CAA6B;IAC5D,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,cAAc,CAAY;IAClC,OAAO,CAAC,sBAAsB,CAAoB;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,kBAAkB,CAAY;IAEtC;;;;;;;;OAQG;gBACS,EACR,YAAY,EACZ,MAAM,EACN,eAAe,EACf,sBAAsB,EACtB,yBAAyB,EACzB,MAAM,GACT,EAAE;QACC,YAAY,EAAE,YAAY,CAAA;QAC1B,MAAM,EAAE,0BAA0B,CAAA;QAClC,eAAe,EAAE,eAAe,CAAA;QAChC,sBAAsB,EAAE,sBAAsB,CAAA;QAC9C,yBAAyB,EAAE,yBAAyB,CAAA;QACpD,MAAM,CAAC,EAAE,WAAW,CAAA;KACvB;IAmDD;;;OAGG;IACG,IAAI;IAqHV;;;OAGG;IACH,0BAA0B;IAuB1B;;;;OAIG;IACH,6BAA6B,CAAC,KAAK,EAAE,kBAAkB;IA+FvD;;;OAGG;IACH,qBAAqB;IAYrB;;;OAGG;IACH,KAAK;IAaL;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,YAAY,CAAC;QAAC,cAAc,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IAqBvE;;;OAGG;IACH,OAAO,CAAC,OAAO;IAaf;;;OAGG;IACH,KAAK;IAOL;;;OAGG;IACH,qBAAqB;IAMrB;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;OAGG;IACH,MAAM;IAON;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAkCpC;;OAEG;IACH,eAAe,CACX,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM;CAsBtB"}
+{"version":3,"file":"WebRecorder.web.d.ts","sourceRoot":"","sources":["../src/WebRecorder.web.ts"],"names":[],"mappings":"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"}

package/build/WebRecorder.web.js

@@ -20,14 +20,27 @@ export class WebRecorder {
     bitDepth; // Bit depth of the audio
     exportBitDepth; // Bit depth of the audio
     audioAnalysisData; // Keep updating the full audio analysis data with latest events
-    packetCount = 0;
     logger;
     compressedMediaRecorder = null;
     compressedChunks = [];
     compressedSize = 0;
     pendingCompressedChunk = null;
-    wavMimeType = 'audio/wav';
     dataPointIdCounter = 0; // Add this property to track the counter
+    deviceDisconnectionHandler = null;
+    mediaStream = null;
+    onInterruptionCallback;
+    _isDeviceDisconnected = false;
+    /**
+     * Flag to indicate whether this is the first audio chunk after a device switch
+     * Used to maintain proper duration counting
+     */
+    isFirstChunkAfterSwitch = false;
+    /**
+     * Gets whether the recording device has been disconnected
+     */
+    get isDeviceDisconnected() {
+        return this._isDeviceDisconnected;
+    }
     /**
      * Initializes a new WebRecorder instance for audio recording and processing
      * @param audioContext - The AudioContext to use for recording
@@ -35,9 +48,10 @@ export class WebRecorder {
      * @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, logger, }) {
+    constructor({ audioContext, source, recordingConfig, emitAudioEventCallback, emitAudioAnalysisCallback, onInterruption, logger, }) {
         this.audioContext = audioContext;
         this.source = source;
         this.emitAudioEventCallback = emitAudioEventCallback;
@@ -80,6 +94,10 @@ export class WebRecorder {
         if (recordingConfig.compression?.enabled) {
             this.initializeCompressedRecorder();
         }
+        this.mediaStream = source.mediaStream;
+        this.onInterruptionCallback = onInterruption;
+        // Setup device disconnection detection
+        this.setupDeviceDisconnectionDetection();
     }
     /**
      * Initializes the audio worklet using an inline script
@@ -107,12 +125,16 @@ export class WebRecorder {
                 const chunkSize = this.audioContext.sampleRate * 2; // Reduce to 2 seconds chunks
                 const sampleRate = event.data.sampleRate ?? this.audioContext.sampleRate;
                 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;
                 // 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 = this.position + i / sampleRate;
+                    const chunkPosition = incomingPosition + i / sampleRate;
                     // Calculate byte positions and samples
                     const startPosition = Math.floor(i * bytesPerSample);
                     const endPosition = Math.floor((i + chunk.length) * bytesPerSample);
@@ -153,10 +175,11 @@ export class WebRecorder {
                             : undefined,
                     });
                 }
-                this.position += duration;
+                // Update our position based on the worklet's position if provided
+                this.position = incomingPosition + duration;
                 this.pendingCompressedChunk = null;
             };
-            this.logger?.debug(`WebRecorder initialized -- recordSampleRate=${this.audioContext.sampleRate}`, this.config);
+            this.logger?.debug(`WebRecorder initialized -- recordSampleRate=${this.audioContext.sampleRate}, startPosition=${this.position}`, this.config);
             this.audioWorkletNode.port.postMessage({
                 command: 'init',
                 recordSampleRate: this.audioContext.sampleRate,
@@ -165,6 +188,7 @@ export class WebRecorder {
                 exportBitDepth: this.exportBitDepth,
                 channels: this.numberOfChannels,
                 interval: this.config.interval ?? DEFAULT_WEB_INTERVAL,
+                position: this.position, // Pass the current position to the processor
                 // enableLogging: !!this.logger,
             });
             // Connect the source to the AudioWorkletNode and start recording
@@ -191,6 +215,14 @@ export class WebRecorder {
             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) {
@@ -205,29 +237,33 @@ export class WebRecorder {
     handleFeatureExtractorMessage(event) {
         if (event.data.command === 'features') {
             const segmentResult = event.data.result;
-            // Update the dataPointIdCounter based on the last ID received
-            if (segmentResult.dataPoints &&
-                segmentResult.dataPoints.length > 0) {
-                const lastDataPoint = segmentResult.dataPoints[segmentResult.dataPoints.length - 1];
+            // Track existing IDs to prevent duplicates
+            const existingIds = new Set(this.audioAnalysisData.dataPoints.map((dp) => dp.id));
+            // Filter out datapoints with duplicate IDs
+            const uniqueNewDataPoints = segmentResult.dataPoints.filter((dp) => {
+                return !existingIds.has(dp.id);
+            });
+            // Log filtered duplicates if any
+            if (uniqueNewDataPoints.length < segmentResult.dataPoints.length &&
+                this.logger?.warn) {
+                this.logger.warn(`Filtered ${segmentResult.dataPoints.length - uniqueNewDataPoints.length} duplicate datapoints`);
+            }
+            // Update counter based on the highest ID seen
+            if (uniqueNewDataPoints.length > 0) {
+                const lastDataPoint = uniqueNewDataPoints[uniqueNewDataPoints.length - 1];
                 if (lastDataPoint && typeof lastDataPoint.id === 'number') {
-                    this.dataPointIdCounter = Math.max(this.dataPointIdCounter, lastDataPoint.id + 1);
+                    const nextIdValue = lastDataPoint.id + 1;
+                    if (nextIdValue > this.dataPointIdCounter) {
+                        this.dataPointIdCounter = nextIdValue;
+                        this.logger?.debug(`Counter updated to ${this.dataPointIdCounter}`);
+                    }
                 }
             }
-            this.logger?.debug('[WebRecorder] Raw segment result:', {
-                dataPointsLength: segmentResult.dataPoints.length,
-                durationMs: segmentResult.durationMs,
-                sampleRate: segmentResult.sampleRate,
-                amplitudeRange: segmentResult.amplitudeRange,
-            });
-            // Ensure consistent sample rate in the result
-            segmentResult.sampleRate =
-                this.config.sampleRate || this.audioContext.sampleRate;
-            // Update the full audio analysis data with proper range merging
-            this.audioAnalysisData.dataPoints.push(...segmentResult.dataPoints);
+            // Add unique data points to our analysis data
+            this.audioAnalysisData.dataPoints.push(...uniqueNewDataPoints);
             this.audioAnalysisData.durationMs += segmentResult.durationMs;
-            // Make sure the sample rate is consistent
             this.audioAnalysisData.sampleRate = segmentResult.sampleRate;
-            // Properly merge amplitude ranges
+            // Merge amplitude ranges
             if (segmentResult.amplitudeRange) {
                 if (!this.audioAnalysisData.amplitudeRange) {
                     this.audioAnalysisData.amplitudeRange = {
@@ -241,7 +277,7 @@ export class WebRecorder {
                     };
                 }
             }
-            // Properly merge RMS ranges
+            // Merge RMS ranges
             if (segmentResult.rmsRange) {
                 if (!this.audioAnalysisData.rmsRange) {
                     this.audioAnalysisData.rmsRange = {
@@ -255,61 +291,98 @@ export class WebRecorder {
                     };
                 }
             }
-            this.logger?.debug('features event segmentResult', segmentResult);
-            this.logger?.debug(`features event audioAnalysisData duration=${this.audioAnalysisData.durationMs}`, this.audioAnalysisData);
-            this.emitAudioAnalysisCallback(segmentResult);
-            this.logger?.debug('[WebRecorder] Updated audioAnalysisData:', {
-                dataPointsLength: this.audioAnalysisData.dataPoints.length,
-                durationMs: this.audioAnalysisData.durationMs,
-                sampleRate: this.audioAnalysisData.sampleRate,
-                amplitudeRange: this.audioAnalysisData.amplitudeRange,
-            });
+            // Send filtered result to avoid duplicate IDs
+            const filteredSegmentResult = {
+                ...segmentResult,
+                dataPoints: uniqueNewDataPoints,
+            };
+            this.emitAudioAnalysisCallback(filteredSegmentResult);
         }
     }
     /**
-     * Resets the data point ID counter
-     * Used when starting a new recording
+     * 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() {
-        this.dataPointIdCounter = 0;
-        // Reset the counter in the worker
+    resetDataPointCounter(startCounterFrom) {
+        // Set the counter with the passed value or 0
+        this.dataPointIdCounter =
+            startCounterFrom !== undefined ? 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',
-                startCounterFrom: 0,
+                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() {
+        return this.dataPointIdCounter;
+    }
+    /**
+     * Prepares the recorder for continuity after device switch
+     * Sets up all necessary state to maintain proper recording continuity
+     */
+    prepareForDeviceSwitch() {
+        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() {
+    start(preserveCounters = false) {
         this.source.connect(this.audioWorkletNode);
         this.audioWorkletNode.connect(this.audioContext.destination);
-        this.packetCount = 0;
-        // Reset the counter when starting a new recording
-        this.resetDataPointCounter();
+        // 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;
+        }
+        else {
+            this.logger?.debug(`Preserving counter at ${this.dataPointIdCounter} during device switch`);
+        }
         if (this.compressedMediaRecorder) {
             this.compressedMediaRecorder.start(this.config.interval ?? 1000);
         }
     }
     /**
      * Stops the audio recording process and returns the recorded data
+     * @param externalAudioChunks Optional array of Float32Array chunks from previous devices
      * @returns Promise resolving to an object containing PCM data and optional compressed blob
      */
-    async stop() {
+    async stop(externalAudioChunks) {
         try {
-            if (this.compressedMediaRecorder) {
+            // Log what's happening for debugging
+            this.logger?.debug('Stopping recording and collecting final data');
+            // Stop any compressed recording first
+            if (this.compressedMediaRecorder &&
+                this.compressedMediaRecorder.state !== 'inactive') {
                 this.compressedMediaRecorder.stop();
-                return {
-                    pcmData: new Float32Array(), // Return empty array since we're streaming
-                    compressedBlob: new Blob(this.compressedChunks, {
-                        type: 'audio/webm;codecs=opus',
-                    }),
-                };
             }
-            return { pcmData: new Float32Array() };
+            // 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));
+            }
+            // Return the compressed blob if available
+            return {
+                pcmData: new Float32Array(), // Return empty array since we're streaming
+                compressedBlob: this.compressedChunks.length > 0
+                    ? new Blob(this.compressedChunks, {
+                        type: 'audio/webm;codecs=opus',
+                    })
+                    : undefined,
+            };
         }
         finally {
             this.cleanup();
@@ -324,26 +397,63 @@ export class WebRecorder {
      * Closes audio context and disconnects nodes
      */
     cleanup() {
-        if (this.audioContext) {
-            this.audioContext.close();
+        // 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') {
+            try {
+                this.audioContext.close();
+            }
+            catch (e) {
+                // Ignore closure errors - this happens if already closed
+            }
+        }
+        // Safely disconnect audioWorkletNode if it exists
         if (this.audioWorkletNode) {
-            this.audioWorkletNode.disconnect();
+            try {
+                this.audioWorkletNode.disconnect();
+            }
+            catch (e) {
+                // Ignore disconnection errors - node might be already disconnected
+            }
         }
+        // Safely disconnect source if it exists
         if (this.source) {
-            this.source.disconnect();
+            try {
+                this.source.disconnect();
+            }
+            catch (e) {
+                // Ignore disconnection errors - source might be already disconnected
+            }
         }
+        // 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() {
-        this.source.disconnect(this.audioWorkletNode); // Disconnect the source from the AudioWorkletNode
-        this.audioWorkletNode.disconnect(this.audioContext.destination); // Disconnect the AudioWorkletNode from the destination
-        this.audioWorkletNode.port.postMessage({ command: 'pause' });
-        this.compressedMediaRecorder?.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
@@ -351,8 +461,14 @@ export class WebRecorder {
      */
     stopMediaStreamTracks() {
         // Stop all audio tracks to stop the recording icon
-        const tracks = this.source.mediaStream.getTracks();
-        tracks.forEach((track) => track.stop());
+        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
@@ -377,10 +493,20 @@ export class WebRecorder {
      * Reconnects audio nodes and resumes the media recorder
      */
     resume() {
-        this.source.connect(this.audioWorkletNode);
-        this.audioWorkletNode.connect(this.audioContext.destination);
-        this.audioWorkletNode.port.postMessage({ command: 'resume' });
-        this.compressedMediaRecorder?.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) {
+            this.logger?.error('Error in resume(): ', error);
+        }
     }
     /**
      * Initializes the compressed media recorder if compression is enabled
@@ -428,9 +554,92 @@ export class WebRecorder {
                 startPosition,
                 endPosition,
                 samples,
-                startCounterFrom: this.dataPointIdCounter, // Pass the current counter value
             });
         }
     }
+    /**
+     * Sets up detection for device disconnection events
+     */
+    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
+                }
+            }
+        };
+        // 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) {
+        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() {
+        return this.position;
+    }
+    /**
+     * Gets the current compressed chunks
+     * @returns Array of current compressed audio chunks
+     */
+    getCompressedChunks() {
+        return [...this.compressedChunks];
+    }
+    /**
+     * Sets the compressed chunks from a previous recorder
+     * @param chunks Array of compressed chunks from a previous recorder
+     */
+    setCompressedChunks(chunks) {
+        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);
+        }
+    }
 }
 //# sourceMappingURL=WebRecorder.web.js.map