@siteed/audio-studio 3.2.1-beta.0 → 3.2.1-beta.2

package/build/types/utils/nativeRecordingOptions.d.ts

@@ -0,0 +1,28 @@
+import { RecordingConfig } from '../AudioStudio.types';
+export declare function createNativeRecordingOptions(recordingOptions: RecordingConfig): {
+    sampleRate?: import("..").SampleRate;
+    channels?: 1 | 2;
+    encoding?: import("..").EncodingType;
+    interval?: number;
+    intervalAnalysis?: number;
+    keepAwake?: boolean;
+    showNotification?: boolean;
+    showWaveformInNotification?: boolean;
+    notification?: import("..").NotificationConfig;
+    enableProcessing?: boolean;
+    ios?: import("..").IOSConfig;
+    android?: import("..").AndroidConfig;
+    web?: import("..").WebConfig;
+    segmentDurationMs?: number;
+    features?: import("..").AudioFeaturesOptions;
+    output?: import("..").OutputConfig;
+    autoResumeAfterInterruption?: boolean;
+    maxDurationMs?: number;
+    outputDirectory?: string;
+    filename?: string;
+    deviceId?: string;
+    deviceDisconnectionBehavior?: import("..").DeviceDisconnectionBehaviorType;
+    bufferDurationSeconds?: number;
+    streamFormat?: "float32" | "raw";
+};
+//# sourceMappingURL=nativeRecordingOptions.d.ts.map

package/build/types/utils/nativeRecordingOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeRecordingOptions.d.ts","sourceRoot":"","sources":["../../../src/utils/nativeRecordingOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAGtD,wBAAgB,4BAA4B,CAAC,gBAAgB,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;EAgB7E"}

package/build/types/utils/nativeRecordingOptions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nativeRecordingOptions.test.d.ts.map

package/build/types/utils/nativeRecordingOptions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeRecordingOptions.test.d.ts","sourceRoot":"","sources":["../../../src/utils/nativeRecordingOptions.test.ts"],"names":[],"mappings":""}

package/ios/AudioStreamManager.swift

@@ -11,6 +11,7 @@ import Accelerate
 import UIKit
 import MediaPlayer
 import UserNotifications
+import QuartzCore
 
 // Constants
 internal let WAV_HEADER_SIZE: Int64 = 44  // Standard WAV header is 44 bytes
@@ -48,6 +49,11 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     private var startTime: Date?
     private var totalPausedDuration: TimeInterval = 0  // Track total paused time
     private var currentPauseStart: Date?              // Track current pause start
+    private var maxDurationTimer: DispatchSourceTimer?
+    private var maxDurationTargetMs: Int64 = 0
+    private var maxDurationAccumulatedActiveMs: Double = 0
+    private var maxDurationSegmentStart: CFTimeInterval?
+    private var maxDurationReached: Bool = false
     var isRecording = false
     var isPaused = false
     var isPrepared = false  // Add this new state flag
@@ -690,37 +696,39 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     /// Gets the current status of the recording.
     /// - Returns: A dictionary containing the recording status information.
     func getStatus() -> [String: Any] {
-        guard let settings = recordingSettings else {
-            print("Recording settings are not available.")
-            return [:]
-        }
-        
         let durationInSeconds = currentRecordingDuration()
         let durationInMilliseconds = Int(durationInSeconds * 1000)
+        let settings = recordingSettings
         
         var status: [String: Any] = [
             "durationMs": durationInMilliseconds,
             "isRecording": isRecording,
             "isPaused": isPaused,
             "mimeType": mimeType,
-            "size": totalDataSize
+            "size": totalDataSize,
+            "maxDurationReached": maxDurationReached
         ]
+
+        let statusMaxDurationMs = settings?.maxDurationMs ?? maxDurationTargetMs
+        if statusMaxDurationMs > 0 {
+            status["maxDurationMs"] = statusMaxDurationMs
+        }
         
         // Safely handle optional interval values
-        if let interval = settings.interval {
+        if let interval = settings?.interval {
             status["interval"] = interval
         } else {
             status["interval"] = 1000 // Default value
         }
         
-        if let intervalAnalysis = settings.intervalAnalysis {
+        if let intervalAnalysis = settings?.intervalAnalysis {
             status["intervalAnalysis"] = intervalAnalysis
         } else {
             status["intervalAnalysis"] = 500 // Default value
         }
         
         // Add compression info if enabled
-        if settings.output.compressed.enabled,
+        if settings?.output.compressed.enabled == true,
            let compressedURL = compressedFileURL,
            FileManager.default.fileExists(atPath: compressedURL.path) {
             do {
@@ -744,6 +752,86 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         return status
     }
 
+    private func maxDurationActiveMs(now: CFTimeInterval = CACurrentMediaTime()) -> Double {
+        if let segmentStart = maxDurationSegmentStart {
+            return maxDurationAccumulatedActiveMs + ((now - segmentStart) * 1000)
+        }
+        return maxDurationAccumulatedActiveMs
+    }
+
+    private func startMaxDurationTimer(settings: RecordingSettings) {
+        cancelMaxDurationTimer()
+        maxDurationReached = false
+        maxDurationTargetMs = settings.maxDurationMs
+        maxDurationAccumulatedActiveMs = 0
+        maxDurationSegmentStart = nil
+        guard settings.maxDurationMs > 0 else { return }
+
+        maxDurationSegmentStart = CACurrentMediaTime()
+        scheduleMaxDurationTimer()
+    }
+
+    private func scheduleMaxDurationTimer() {
+        guard maxDurationTargetMs > 0, !maxDurationReached, isRecording, !isPaused else {
+            return
+        }
+
+        maxDurationTimer?.cancel()
+        let remainingMs = max(0, Double(maxDurationTargetMs) - maxDurationActiveMs())
+        let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.main)
+        timer.schedule(deadline: .now() + .milliseconds(Int(remainingMs.rounded(.up))))
+        timer.setEventHandler { [weak self] in
+            self?.maxDurationTimer = nil
+            self?.emitMaxDurationReached()
+        }
+        maxDurationTimer = timer
+        timer.resume()
+    }
+
+    private func pauseMaxDurationTimer() {
+        maxDurationTimer?.cancel()
+        maxDurationTimer = nil
+        if maxDurationSegmentStart != nil {
+            maxDurationAccumulatedActiveMs = maxDurationActiveMs()
+            maxDurationSegmentStart = nil
+        }
+    }
+
+    private func resumeMaxDurationTimer() {
+        guard maxDurationTargetMs > 0, !maxDurationReached else { return }
+        maxDurationSegmentStart = CACurrentMediaTime()
+        scheduleMaxDurationTimer()
+    }
+
+    private func cancelMaxDurationTimer() {
+        maxDurationTimer?.cancel()
+        maxDurationTimer = nil
+        maxDurationSegmentStart = nil
+        if !maxDurationReached {
+            maxDurationTargetMs = 0
+            maxDurationAccumulatedActiveMs = 0
+        }
+    }
+
+    private func emitMaxDurationReached() {
+        guard maxDurationTargetMs > 0, !maxDurationReached else { return }
+        guard isRecording, !isPaused else { return }
+
+        let durationMs = Int64(maxDurationActiveMs().rounded())
+        maxDurationReached = true
+        let shouldAutoStop = recordingSettings?.autoStopOnMaxDuration == true
+        delegate?.audioStreamManager(self, didReachMaxDuration: [
+            "durationMs": durationMs,
+            "maxDurationMs": maxDurationTargetMs,
+            "overrunMs": max(Int64(0), durationMs - maxDurationTargetMs),
+            "streamUuid": recordingUUID ?? "",
+            "autoStopped": shouldAutoStop
+        ])
+        if shouldAutoStop {
+            _ = stopRecording()
+        }
+    }
+
     /// Builds compression info dictionary with incremental compressed data for streaming events.
     /// Mirrors the Android pattern (AudioRecorderManager.kt) for consistent cross-platform behavior.
     /// - Returns: A dictionary containing compression metadata and base64-encoded data chunk, or nil if compression is disabled.
@@ -1179,6 +1267,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             isRecording = true
             isPaused = false
             pausedBySystemInterruption = false
+            startMaxDurationTimer(settings: settings)
             
             // Start the audio engine
             try audioEngine.start()
@@ -1220,6 +1309,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         } catch {
             Logger.debug("Error starting audio engine: \(error.localizedDescription)")
             isRecording = false
+            cancelMaxDurationTimer()
             cleanupPreparation()
             return nil
         }
@@ -1231,6 +1321,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         guard isPrepared && !isRecording else { return }
         
         Logger.debug("Cleaning up prepared resources that weren't used")
+        cancelMaxDurationTimer()
         
         // Remove input tap
         audioEngine.inputNode.removeTap(onBus: 0)
@@ -1296,6 +1387,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
 
         // Store when we paused
         currentPauseStart = Date()
+        pauseMaxDurationTimer()
         
         // Update state
         isPaused = true
@@ -1357,6 +1449,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             
             // Clear the stored valid duration
             lastValidDuration = nil
+            resumeMaxDurationTimer()
             
             // Reset emission timers to ensure emission starts immediately after resume
             lastEmissionTime = Date()
@@ -1843,6 +1936,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         
         // Set stopping flag to prevent race conditions with background/foreground transitions
         stopping = true
+        cancelMaxDurationTimer()
         
         Logger.debug("Stopping recording...")
         

package/ios/AudioStreamManagerDelegate.swift

@@ -12,5 +12,6 @@ protocol AudioStreamManagerDelegate: AnyObject {
     func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date)
     func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool)
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any])
+    func audioStreamManager(_ manager: AudioStreamManager, didReachMaxDuration info: [String: Any])
     func audioStreamManager(_ manager: AudioStreamManager, didFailWithError error: String)
 }

package/ios/AudioStudioModule.swift

@@ -6,6 +6,7 @@ import AVFoundation
 private let audioDataEvent: String = "AudioData"
 private let audioAnalysisEvent: String = "AudioAnalysis"
 private let recordingInterruptedEvent: String = "onRecordingInterrupted"
+private let maxDurationReachedEvent: String = "MaxDurationReached"
 private let deviceChangedEvent: String = "deviceChangedEvent"
 private let trimProgressEvent: String = "TrimProgress"
 private let errorEvent: String = "error"
@@ -48,6 +49,7 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
             audioDataEvent,
             audioAnalysisEvent,
             recordingInterruptedEvent,
+            maxDurationReachedEvent,
             deviceChangedEvent,
             trimProgressEvent,
             errorEvent,
@@ -1122,6 +1124,10 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
             "timestamp": Date().timeIntervalSince1970 * 1000
         ])
     }
+
+    func audioStreamManager(_ manager: AudioStreamManager, didReachMaxDuration info: [String: Any]) {
+        sendEvent(maxDurationReachedEvent, info)
+    }
     
     func audioStreamManager(_ manager: AudioStreamManager, didPauseRecording pauseTime: Date) {
         Logger.debug("AudioStudioModule", "Delegate: didPauseRecording")

package/ios/RecordingSettings.swift

@@ -22,13 +22,13 @@ struct OutputSettings {
         var enabled: Bool = true
         var format: String = "wav"  // Currently only "wav" is supported
     }
-    
+
     struct CompressedOutput {
         var enabled: Bool = false
         var format: String = "aac"  // "aac" or "opus" (opus falls back to aac on iOS)
         var bitrate: Int = 128000
     }
-    
+
     var primary: PrimaryOutput = PrimaryOutput()
     var compressed: CompressedOutput = CompressedOutput()
 }
@@ -39,13 +39,13 @@ struct CompressedRecordingInfo {
     var bitrate: Int
     var format: String
     var size: Int64 = 0  // Add size with default value
-    
+
     static func validate(format: String, bitrate: Int) -> Result<(String, Int), Error> {
         // Validate format
         guard ["aac", "opus"].contains(format.lowercased()) else {
             return .failure(RecordingError.unsupportedFormat(format))
         }
-        
+
         // Adjust bitrate based on format
         let adjustedBitrate: Int
         if format.lowercased() == "aac" {
@@ -57,7 +57,7 @@ struct CompressedRecordingInfo {
             // Typical Opus voice bitrates: 8-24 kbps, music: 32-128 kbps
             adjustedBitrate = min(max(bitrate, 8000), 320000)
         }
-        
+
         return .success((format, adjustedBitrate))
     }
 }
@@ -77,7 +77,7 @@ enum RecordingError: Error {
     case unsupportedFormat(String)
     case invalidBitrate(Int)
     case invalidOutputDirectory(String)
-    
+
     var localizedDescription: String {
         switch self {
         case .unsupportedFormat(let format):
@@ -98,56 +98,58 @@ struct RecordingSettings {
     var bitDepth: Int = 16
     var interval: Int?
     var intervalAnalysis: Int?
-    
+
     // Feature flags
     var keepAwake: Bool = true
     var showNotification: Bool = false
     var enableProcessing: Bool = false
-    
+
     // Remove pointsPerSecond and algorithm
     var featureOptions: [String: Bool]? = ["rms": true, "zcr": true]
-    
+
     // iOS-specific configuration
     var ios: IOSConfig?
-    
+
     // Notification configuration
     var notification: NotificationConfig?
-    
+
     // Output configuration
     var output: OutputSettings = OutputSettings()
-    
+
     let autoResumeAfterInterruption: Bool
-    
+
     var outputDirectory: String? = nil
     var filename: String? = nil
-    
+
     // Update default to 100ms
     var segmentDurationMs: Int = 100  // Default 100ms segments
-    
+
     // Add these new properties
     var deviceId: String?
     var deviceDisconnectionBehavior: DeviceDisconnectionBehavior = .FALLBACK
     var bufferDurationSeconds: Double?
     var streamFormat: String = "raw"
-    
+    var maxDurationMs: Int64 = 0
+    var autoStopOnMaxDuration: Bool = false
+
     static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
         // Parse output configuration
         var outputSettings = OutputSettings()
-        
+
         if let outputDict = dict["output"] as? [String: Any] {
             // Parse primary output settings
             if let primaryDict = outputDict["primary"] as? [String: Any] {
                 outputSettings.primary.enabled = primaryDict["enabled"] as? Bool ?? true
                 outputSettings.primary.format = primaryDict["format"] as? String ?? "wav"
             }
-            
+
             // Parse compressed output settings
             if let compressedDict = outputDict["compressed"] as? [String: Any] {
                 outputSettings.compressed.enabled = compressedDict["enabled"] as? Bool ?? false
                 let format = (compressedDict["format"] as? String)?.lowercased() ?? "aac"
                 outputSettings.compressed.format = format
                 outputSettings.compressed.bitrate = compressedDict["bitrate"] as? Int ?? 128000
-                
+
                 // Validate compression settings if enabled
                 if outputSettings.compressed.enabled {
                     if case .failure(let error) = CompressedRecordingInfo.validate(
@@ -159,40 +161,43 @@ struct RecordingSettings {
                 }
             }
         }
-        
+
         // Add extraction of new properties
         let deviceId = dict["deviceId"] as? String
         let deviceDisconnectionBehaviorStr = dict["deviceDisconnectionBehavior"] as? String
-        
+
         // Create settings
         var settings = RecordingSettings(
             sampleRate: dict["sampleRate"] as? Double ?? 44100.0,
             desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0,
             autoResumeAfterInterruption: dict["autoResumeAfterInterruption"] as? Bool ?? false
         )
-        
+
         settings.output = outputSettings
-        
+
         // Parse core settings
         settings.numberOfChannels = dict["channels"] as? Int ?? 1
         settings.bitDepth = dict["bitDepth"] as? Int ?? 16
         settings.interval = dict["interval"] as? Int
         settings.intervalAnalysis = dict["intervalAnalysis"] as? Int
-        
+        if let maxDurationNumber = dict["maxDurationMs"] as? NSNumber {
+            settings.maxDurationMs = maxDurationNumber.int64Value
+        }
+        settings.autoStopOnMaxDuration = dict["autoStopOnMaxDuration"] as? Bool ?? false
         // Parse feature flags
         settings.keepAwake = dict["keepAwake"] as? Bool ?? true
         settings.showNotification = dict["showNotification"] as? Bool ?? false
         settings.enableProcessing = dict["enableProcessing"] as? Bool ?? false
-        
+
         settings.featureOptions = dict["features"] as? [String: Bool]
-        
+
         // Update segmentDurationMs parsing
         settings.segmentDurationMs = dict["segmentDurationMs"] as? Int ?? 100
-        
+
         // Parse iOS-specific config
         if let iosDict = dict["ios"] as? [String: Any],
            let audioSessionDict = iosDict["audioSession"] as? [String: Any] {
-            
+
             // Map category
             let category: AVAudioSession.Category
             if let categoryStr = audioSessionDict["category"] as? String {
@@ -208,7 +213,7 @@ struct RecordingSettings {
             } else {
                 category = .record
             }
-            
+
             // Map mode
             let mode: AVAudioSession.Mode
             if let modeStr = audioSessionDict["mode"] as? String {
@@ -226,7 +231,7 @@ struct RecordingSettings {
             } else {
                 mode = .default
             }
-            
+
             // Map category options
             var categoryOptions: AVAudioSession.CategoryOptions = []
             if let optionsArray = audioSessionDict["categoryOptions"] as? [String] {
@@ -243,63 +248,63 @@ struct RecordingSettings {
                     }
                 }
             }
-            
+
             settings.ios = IOSConfig(audioSession: IOSAudioSessionConfig(
                 category: category,
                 mode: mode,
                 categoryOptions: categoryOptions
             ))
         }
-        
+
         // Parse notification config
         if let notificationDict = dict["notification"] as? [String: Any] {
             var notificationConfig = NotificationConfig()
             notificationConfig.title = notificationDict["title"] as? String
             notificationConfig.text = notificationDict["text"] as? String
             notificationConfig.icon = notificationDict["icon"] as? String
-            
+
             // Parse iOS-specific notification config
             if let iosNotificationDict = notificationDict["ios"] as? [String: Any] {
                 notificationConfig.ios = IOSNotificationConfig(
                     categoryIdentifier: iosNotificationDict["categoryIdentifier"] as? String
                 )
             }
-            
+
             settings.notification = notificationConfig
         }
-        
+
         // Parse output settings (they remain nil if not provided)
         if let directory = dict["outputDirectory"] as? String {
             // Only validate if a custom directory is provided
             let fileManager = FileManager.default
             var isDirectory: ObjCBool = false
-            
+
             // Clean up the directory path by removing file:// protocol if present
             let cleanDirectory = directory.replacingOccurrences(of: "file://", with: "")
                 .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
                 .replacingOccurrences(of: "//", with: "/")
-            
+
             if !fileManager.fileExists(atPath: cleanDirectory, isDirectory: &isDirectory) {
                 return .failure(RecordingError.invalidOutputDirectory("Directory does not exist: \(cleanDirectory)"))
             }
-            
+
             if !isDirectory.boolValue {
                 return .failure(RecordingError.invalidOutputDirectory("Path is not a directory: \(cleanDirectory)"))
             }
-            
+
             if !fileManager.isWritableFile(atPath: cleanDirectory) {
                 return .failure(RecordingError.invalidOutputDirectory("Directory is not writable: \(cleanDirectory)"))
             }
-            
+
             settings.outputDirectory = cleanDirectory
         }
-        
+
         settings.filename = dict["filename"] as? String
-        
+
         // Set new properties
         settings.deviceId = deviceId
         settings.deviceDisconnectionBehavior = DeviceDisconnectionBehavior(rawValue: deviceDisconnectionBehaviorStr ?? "fallback") ?? .FALLBACK
-        
+
         if let bufferDuration = dict["bufferDurationSeconds"] as? Double {
             settings.bufferDurationSeconds = bufferDuration
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/audio-studio",
-    "version": "3.2.1-beta.0",
+    "version": "3.2.1-beta.2",
     "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/AudioStudio.types.ts

@@ -4,7 +4,7 @@ import {
     AudioFeaturesOptions,
     DecodingConfig,
 } from './AudioAnalysis/AudioAnalysis.types'
-import { AudioAnalysisEvent } from './events'
+import type { AudioAnalysisEvent } from './events'
 
 export interface CompressionInfo {
     /** Size of the compressed audio data in bytes */
@@ -36,6 +36,10 @@ export interface AudioStreamStatus {
     mimeType: string
     /** Information about audio compression if enabled */
     compression?: CompressionInfo
+    /** Configured maximum active recording duration in milliseconds, if enabled */
+    maxDurationMs?: number
+    /** Whether the current recording session has reached the configured maximum duration */
+    maxDurationReached?: boolean
 }
 
 interface AudioDataEventBase {
@@ -190,6 +194,21 @@ export interface StartRecordingResult {
     }
 }
 
+export interface MaxDurationReachedEvent {
+    /** Active recording duration that triggered the event, in milliseconds */
+    durationMs: number
+    /** Configured active recording duration limit, in milliseconds */
+    maxDurationMs: number
+    /** Amount by which timer delivery exceeded the limit, in milliseconds */
+    overrunMs: number
+    /** Active stream identifier when available */
+    streamUuid?: string
+    /** Whether the recorder was configured to stop automatically after this event */
+    autoStopped: boolean
+}
+
+export type RecordingStopReason = 'manual' | 'maxDuration'
+
 export interface AudioSessionConfig {
     /**
      * Audio session category that defines the audio behavior
@@ -484,6 +503,43 @@ export interface RecordingConfig {
     /** Optional callback to handle recording interruptions */
     onRecordingInterrupted?: (_: RecordingInterruptionEvent) => void
 
+    /**
+     * Maximum cumulative active recording duration, in milliseconds.
+     *
+     * Paused time does not count. Set to undefined, 0, or a negative value to disable.
+     */
+    maxDurationMs?: number
+
+    /**
+     * Stop recording automatically when maxDurationMs is reached.
+     *
+     * Defaults to false. When used with `useAudioRecorder`, the
+     * MaxDurationReached event is emitted immediately, then the hook stops the
+     * recorder and exposes the final result through `onRecordingStopped`.
+     */
+    autoStopOnMaxDuration?: boolean
+
+    /**
+     * Optional callback invoked when maxDurationMs is reached.
+     *
+     * This remains an immediate threshold callback. If
+     * autoStopOnMaxDuration is true, use `onRecordingStopped` for the full
+     * recording result after stop completes.
+     */
+    onMaxDurationReached?: (_: MaxDurationReachedEvent) => void
+
+    /**
+     * Optional callback invoked after a recording has fully stopped and the
+     * final `AudioRecording` result is available.
+     *
+     * The reason is `manual` when stopped through `stopRecording()` and
+     * `maxDuration` when stopped by `autoStopOnMaxDuration`.
+     */
+    onRecordingStopped?: (
+        recording: AudioRecording,
+        reason: RecordingStopReason
+    ) => void | Promise<void>
+
     /** Optional directory path where output files will be saved */
     outputDirectory?: string // If not provided, uses default app directory
     /** Optional filename for the recording (uses UUID if not provided) */
@@ -710,10 +766,23 @@ export interface UseAudioRecorderState {
     size: number // Size in bytes of the recorded audio
     /** Information about compression if enabled */
     compression?: CompressionInfo
+    /** Configured maximum active recording duration in milliseconds, if enabled */
+    maxDurationMs?: number
+    /** Whether the current recording session has reached the configured maximum duration */
+    maxDurationReached?: boolean
     /** Analysis data for the recording if processing was enabled */
     analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
+    /** Reason associated with the last completed recording */
+    lastRecordingReason?: RecordingStopReason
     /** Optional callback to handle recording interruptions */
     onRecordingInterrupted?: (_: RecordingInterruptionEvent) => void
+    /** Optional callback invoked when maxDurationMs is reached */
+    onMaxDurationReached?: (_: MaxDurationReachedEvent) => void
+    /** Optional callback invoked when a recording fully stops */
+    onRecordingStopped?: (
+        recording: AudioRecording,
+        reason: RecordingStopReason
+    ) => void | Promise<void>
 }
 
 /**