node-mac-recorder 2.24.10 → 2.24.12

package/src/audio_recorder.mm

@@ -1,3 +1,4 @@
+#import "recording_writer_safety.h"
 #import <Foundation/Foundation.h>
 #import <AVFoundation/AVFoundation.h>
 #import "logging.h"
@@ -250,8 +251,8 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
     MRLog(@"🛑 AudioRecorder: Stopping session (external device safe)...");
 
     // Stop session on background thread to avoid blocking
-    AVCaptureSession *sessionToStop = self.session;
-    AVCaptureAudioDataOutput *outputToStop = self.audioOutput;
+    AVCaptureSession *sessionToStop = [self.session retain];
+    AVCaptureAudioDataOutput *outputToStop = [self.audioOutput retain];
 
     // Clear references FIRST to prevent new samples
     self.session = nil;
@@ -260,51 +261,27 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
     // Stop session asynchronously with timeout protection
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
         @autoreleasepool {
+          @try {
             if ([sessionToStop isRunning]) {
                 MRLog(@"🛑 Stopping AVCaptureSession...");
                 [sessionToStop stopRunning];
                 MRLog(@"✅ AVCaptureSession stopped");
             }
+          } @catch (NSException *exception) {
+            NSLog(@"[Recorder] Microphone session stop failed safely: %@", exception.reason);
+          }
             // Release happens automatically when block completes
         }
     });
 
-    // CRITICAL FIX: Check if writer exists before trying to finish it
-    if (self.writer) {
-        // Only mark as finished if writerInput exists
-        if (self.writerInput) {
-            [self.writerInput markAsFinished];
-        }
-
-        __block BOOL finished = NO;
-        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-
-        [self.writer finishWritingWithCompletionHandler:^{
-            finished = YES;
-            dispatch_semaphore_signal(semaphore);
-        }];
-
-        // SYNC FIX: Match camera timeout (3 seconds) for consistent finish timing
-        const int64_t primaryWaitSeconds = 3;
-        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(primaryWaitSeconds * NSEC_PER_SEC));
-        long result = dispatch_semaphore_wait(semaphore, timeout);
-
-        if (result != 0 || !finished) {
-            MRLog(@"⚠️ AudioRecorder: Writer still finishing after %ds – waiting longer", (int)primaryWaitSeconds);
-            const int64_t extendedWaitSeconds = 5;
-            dispatch_time_t extendedTimeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(extendedWaitSeconds * NSEC_PER_SEC));
-            result = dispatch_semaphore_wait(semaphore, extendedTimeout);
-        }
-
-        if (result != 0 || !finished) {
-            MRLog(@"⚠️ AudioRecorder: Writer did not finish after extended wait – forcing cancel");
-            [self.writer cancelWriting];
-        } else {
-            MRLog(@"✅ AudioRecorder writer finished successfully");
-        }
-    } else {
-        MRLog(@"⚠️ AudioRecorder: No writer to finish (no audio captured)");
-    }
+    // Detach callbacks before draining; otherwise a late audio sample can
+    // recreate or append to a writer which is being finalized.
+    [sessionToStop release]; // the copied dispatch block owns it now
+    @try { [outputToStop setSampleBufferDelegate:nil queue:nil]; }
+    @catch (NSException *exception) { NSLog(@"[Recorder] Microphone delegate detach: %@", exception.reason); }
+    [outputToStop release];
+    if (g_audioCaptureQueue) dispatch_sync(g_audioCaptureQueue, ^{});
+    MRFinishAssetWriterSafely(self.writer, 8.0);
 
     self.writer = nil;
     self.writerInput = nil;
@@ -319,6 +296,11 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
 #pragma mark - AVCaptureAudioDataOutputSampleBufferDelegate
 
 - (void)captureOutput:(AVCaptureOutput *)output didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection {
+    if (!self.session || output != self.audioOutput) return;
+    @try {
+    if (MRSyncIsPaused()) {
+        return;
+    }
     if (!CMSampleBufferDataIsReady(sampleBuffer)) {
         return;
     }
@@ -390,6 +372,7 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
                         if (CMTIME_COMPARE_INLINE(adjustedPTS, <, kCMTimeZero)) {
                             adjustedPTS = kCMTimeZero;
                         }
+                        adjustedPTS = MRSyncAdjustForPauses(adjustedPTS);
                         timingInfo[i].presentationTimeStamp = adjustedPTS;
                         
                         if (stopLimit > 0) {
@@ -409,7 +392,7 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
                         if (CMTIME_COMPARE_INLINE(adjustedDTS, <, kCMTimeZero)) {
                             adjustedDTS = kCMTimeZero;
                         }
-                        timingInfo[i].decodeTimeStamp = adjustedDTS;
+                        timingInfo[i].decodeTimeStamp = MRSyncAdjustForPauses(adjustedDTS);
                     }
                 }
                 
@@ -433,7 +416,8 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
         // No timing info available; approximate using buffer timestamp.
         CMTime pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
         if (CMTIME_IS_VALID(pts)) {
-            double relativeStart = CMTimeGetSeconds(CMTimeSubtract(pts, self.startTime));
+            double relativeStart = CMTimeGetSeconds(
+                MRSyncAdjustForPauses(CMTimeSubtract(pts, self.startTime)));
             if (relativeStart > stopLimit + audioTolerance) {
                 shouldDropBuffer = YES;
             }
@@ -454,6 +438,10 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
     if (bufferToAppend != sampleBuffer) {
         CFRelease(bufferToAppend);
     }
+    } @catch (NSException *exception) {
+        NSLog(@"[Recorder] Audio sample failed safely: %@", exception.reason);
+    }
+
 }
 
 @end
@@ -532,8 +520,8 @@ bool startStandaloneAudioRecording(NSString *outputPath,
         return false;
     }
     
-    __block BOOL audioPermissionGranted = YES;
     AVAuthorizationStatus audioStatus = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
+    __block BOOL audioPermissionGranted = (audioStatus == AVAuthorizationStatusAuthorized);
     if (audioStatus == AVAuthorizationStatusNotDetermined) {
         dispatch_semaphore_t permissionSemaphore = dispatch_semaphore_create(0);
         [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
@@ -555,9 +543,21 @@ bool startStandaloneAudioRecording(NSString *outputPath,
     
     g_audioRecorder = [[NativeAudioRecorder alloc] init];
     if (outputPath && [outputPath length] > 0) {
-        g_lastStandaloneAudioOutputPath = outputPath;
+        NSString *ownedOutputPath = [outputPath copy];
+        [g_lastStandaloneAudioOutputPath release];
+        g_lastStandaloneAudioOutputPath = ownedOutputPath;
+    }
+    @try {
+        BOOL started = [g_audioRecorder startRecordingWithDeviceId:preferredDeviceId outputPath:outputPath error:error];
+        if (!started) [g_audioRecorder stopRecording];
+        return started;
+    } @catch (NSException *exception) {
+        NSLog(@"[Recorder] Microphone startup failed safely: %@", exception.reason);
+        @try { [g_audioRecorder stopRecording]; } @catch (NSException *cleanupError) {}
+        if (error) *error = [NSError errorWithDomain:@"NativeAudioRecorder" code:-22
+            userInfo:@{NSLocalizedDescriptionKey: exception.reason ?: @"Microphone startup failed"}];
+        return false;
     }
-    return [g_audioRecorder startRecordingWithDeviceId:preferredDeviceId outputPath:outputPath error:error];
 }
 
 bool stopStandaloneAudioRecording() {

package/src/avfoundation_recorder.mm

@@ -7,6 +7,8 @@
 #include <string>
 #import "logging.h"
 #import "sync_timeline.h"
+#import "recording_writer_safety.h"
+#include <atomic>
 
 // Import audio recorder
 extern "C" void* createNativeAudioRecorder(void);
@@ -18,9 +20,11 @@ static AVAssetWriter *g_avWriter = nil;
 static AVAssetWriterInput *g_avVideoInput = nil;
 static AVAssetWriterInputPixelBufferAdaptor *g_avPixelBufferAdaptor = nil;
 static dispatch_source_t g_avTimer = nil;
+static dispatch_queue_t g_avCaptureQueue = nil;
+static std::atomic<bool> g_avIsStopping(false);
 static CGDirectDisplayID g_avDisplayID = 0;
 static CGRect g_avCaptureRect = CGRectZero;
-static bool g_avIsRecording = false;
+static std::atomic<bool> g_avIsRecording(false);
 static int64_t g_avFrameNumber = 0;
 static CMTime g_avStartTime;
 static void* g_avAudioRecorder = nil;
@@ -361,6 +365,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
 
         // Start capture timer using target FPS
         dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
+        g_avCaptureQueue = captureQueue;
         g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
         
         if (!g_avTimer) {
@@ -377,6 +382,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         
         dispatch_source_set_event_handler(g_avTimer, ^{
             if (!g_avIsRecording) return;
+            if (MRSyncIsPaused()) return;
 
             // Additional null checks for Electron safety
             if (!localVideoInput || !localPixelBufferAdaptor) {
@@ -482,7 +488,8 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                 if (!CMTIME_IS_VALID(relativeTime) || CMTIME_COMPARE_INLINE(relativeTime, <, kCMTimeZero)) {
                                     relativeTime = kCMTimeZero;
                                 }
-                                CMTime presentationTime = CMTimeMakeWithSeconds(CMTimeGetSeconds(relativeTime), 600);
+                                CMTime presentationTime = MRSyncAdjustForPauses(
+                                    CMTimeMakeWithSeconds(CMTimeGetSeconds(relativeTime), 600));
 
                                 double stopLimit = MRSyncGetStopLimitSeconds();
                                 if (stopLimit > 0) {
@@ -541,75 +548,51 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
 }
 
 extern "C" bool stopAVFoundationRecording() {
-    if (!g_avIsRecording) {
-        return true;
-    }
-
+    if (g_avIsStopping.exchange(true)) return false;
     g_avIsRecording = false;
-
-    // Stop audio recording if active
-    if (g_avAudioRecorder) {
-        MRLog(@"🛑 Stopping audio recording");
-        @try {
-            stopNativeAudioRecording(g_avAudioRecorder);
-            destroyNativeAudioRecorder(g_avAudioRecorder);
-        } @catch (NSException *exception) {
-            NSLog(@"⚠️ Exception while stopping audio: %@", exception.reason);
-        }
-        g_avAudioRecorder = nil;
-        g_avAudioOutputPath = nil;
-        MRLog(@"✅ Audio recording stopped");
-    }
-
+    BOOL finished = YES;
     @try {
-        // Stop timer with Electron-safe cleanup
-        if (g_avTimer) {
-            // Mark as not recording FIRST to stop timer callbacks
-            g_avIsRecording = false;
-            
-            // Cancel timer and wait a brief moment for completion
-            dispatch_source_cancel(g_avTimer);
-            
-            // Use async to avoid deadlock in Electron
-            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 100 * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
-                // Timer should be fully cancelled by now
-            });
-            
-            g_avTimer = nil;
-            MRLog(@"✅ AVFoundation timer stopped safely");
-        }
-        
-        // Finish writing with null checks
-        AVAssetWriterInput *writerInput = g_avVideoInput;
-        if (writerInput) {
-            [writerInput markAsFinished];
-        }
-        
-        AVAssetWriter *writer = g_avWriter;
-        if (writer && writer.status == AVAssetWriterStatusWriting) {
-            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-            [writer finishWritingWithCompletionHandler:^{
-                dispatch_semaphore_signal(semaphore);
-            }];
-            // Add timeout to prevent infinite wait in Electron
-            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
-            dispatch_semaphore_wait(semaphore, timeout);
+        // Cancelling a timer does not wait for an in-flight frame. Drain its
+        // serial queue before finishing or releasing the writer it uses.
+        if (g_avTimer) dispatch_source_cancel(g_avTimer);
+        if (g_avCaptureQueue) dispatch_sync(g_avCaptureQueue, ^{});
+        if (g_avAudioRecorder) {
+            @try {
+                stopNativeAudioRecording(g_avAudioRecorder);
+                destroyNativeAudioRecorder(g_avAudioRecorder);
+            } @catch (NSException *exception) {
+                NSLog(@"[Recorder] Fallback audio stop failed safely: %@", exception.reason);
+            }
+            g_avAudioRecorder = nil;
+            [g_avAudioOutputPath release];
+            g_avAudioOutputPath = nil;
         }
-        
-        // Cleanup
+        finished = MRFinishAssetWriterSafely(g_avWriter, 5.0);
+    } @catch (NSException *exception) {
+        NSLog(@"[Recorder] Fallback stop failed safely: %@", exception.reason);
+        finished = NO;
+    } @finally {
+        [g_avWriter release];
         g_avWriter = nil;
         g_avVideoInput = nil;
         g_avPixelBufferAdaptor = nil;
+        if (g_avTimer) dispatch_release(g_avTimer);
+        g_avTimer = nil;
+        if (g_avCaptureQueue) dispatch_release(g_avCaptureQueue);
+        g_avCaptureQueue = nil;
         g_avFrameNumber = 0;
         g_avStartTime = kCMTimeInvalid;
-        
-        MRLog(@"✅ AVFoundation recording stopped");
-        return true;
-        
-    } @catch (NSException *exception) {
-        NSLog(@"❌ Exception stopping AVFoundation recording: %@", exception.reason);
-        return false;
+        g_avIsStopping = false;
     }
+    return finished;
+}
+
+extern "C" bool hasAVFoundationRecordingResources() {
+    return g_avIsRecording || g_avIsStopping || g_avWriter != nil || g_avTimer != nil || g_avAudioRecorder != nil;
+}
+
+extern "C" bool isAVFoundationRecordingStopping() {
+    return g_avIsStopping;
 }
 
 extern "C" bool isAVFoundationRecording() {

package/src/camera_recorder.mm

@@ -1,3 +1,4 @@
+#import "recording_writer_safety.h"
 #import <AVFoundation/AVFoundation.h>
 #import <CoreMedia/CoreMedia.h>
 #import <CoreVideo/CoreVideo.h>
@@ -506,6 +507,12 @@ static void MRCameraRemoveFileIfExists(NSString *path) {
 - (void)captureOutput:(AVCaptureOutput *)output
 didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
        fromConnection:(AVCaptureConnection *)connection {
+    if (self.stopInFlight || !self.isRecording || output != self.videoOutput) return;
+    @try {
+
+    if (MRSyncIsPaused()) {
+        return;
+    }
 
     if (!CMSampleBufferDataIsReady(sampleBuffer)) {
         return;
@@ -535,6 +542,12 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
     // A/V SYNC: Signal camera's first frame to release audio hold
     MRSyncMarkCameraFirstFrame(timestamp);
 
+    // "Ready" means the capture device delivered a real frame, not that the
+    // writer already received audio. Signaling here lets the primary recorder
+    // start its audio source; waiting until writer start creates a camera/audio
+    // barrier cycle and can hold startup until the timeout.
+    [self completeStart:YES token:self.activeToken];
+
     // Hold camera frames until we see audio so timelines stay aligned
     if (MRSyncShouldHoldVideoFrame(timestamp)) {
         return;
@@ -573,8 +586,6 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
         
         g_cameraStartTimestamp = CFAbsoluteTimeGetCurrent();
 
-        // Signal start completion
-        [self completeStart:YES token:self.activeToken];
     }
 
     if (!self.writerInput.readyForMoreMediaData) {
@@ -595,6 +606,7 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
         // This should not happen if sync is working correctly
         adjustedTimestamp = kCMTimeZero;
     }
+    adjustedTimestamp = MRSyncAdjustForPauses(adjustedTimestamp);
 
     // LIP SYNC FIX: Check stopLimit OR elapsed time to drop frames after recording duration
     // This prevents camera from recording longer than audio
@@ -604,7 +616,9 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
 
     // CRITICAL FIX: Also check elapsed time since recording started
     // This works even if stopLimit hasn't been set yet
-    double elapsedTime = (g_cameraStartTimestamp > 0) ? (CFAbsoluteTimeGetCurrent() - g_cameraStartTimestamp) : 0;
+    double elapsedTime = (g_cameraStartTimestamp > 0)
+        ? MAX(0, CFAbsoluteTimeGetCurrent() - g_cameraStartTimestamp - MRSyncGetPausedDurationSeconds())
+        : 0;
     double maxDuration = (stopLimit > 0) ? stopLimit : elapsedTime + 1.0;  // Use stopLimit if available, else allow 1s more
 
     // DEBUG: Log every 30th frame
@@ -642,6 +656,12 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
     if (!success) {
         MRLog(@"⚠️ Failed to append camera pixel buffer: %@", self.writer.error);
     }
+    } @catch (NSException *exception) {
+        NSLog(@"[Recorder] Camera sample failed safely: %@", exception.reason);
+        [self completeStart:NO token:self.activeToken];
+        self.isRecording = NO;
+    }
+
 }
 
 #pragma mark - Synchronization helpers
@@ -655,7 +675,8 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
 
 - (BOOL)waitForStopCompletion:(NSTimeInterval)timeout {
     dispatch_semaphore_t stopSemaphore = self.stopSemaphore;
-    if (!stopSemaphore) {
+    if (!stopSemaphore || !self.stopInFlight) {
+        self.stopSemaphore = nil;
         return YES;
     }
     dispatch_time_t waitTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeout * NSEC_PER_SEC));
@@ -884,96 +905,57 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
     uint64_t token = [self nextToken];
 
     dispatch_async(self.workQueue, ^{
-        [self performStartWithDeviceId:deviceId outputPath:outputPath token:token];
+        @try {
+            [self performStartWithDeviceId:deviceId outputPath:outputPath token:token];
+        } @catch (NSException *exception) {
+            NSLog(@"[Recorder] Camera startup failed safely: %@", exception.reason);
+            [self completeStart:NO token:token];
+        }
     });
 
     return YES;
 }
 
 - (BOOL)stopRecording {
-    BOOL hasActiveSession = (self.session && [self.session isRunning]);
-    BOOL writerActive = (self.writer && self.writerStarted);
-    if (!self.isRecording && !hasActiveSession && !writerActive) {
-        [self waitForStopCompletion:5.0];
-        return YES;
-    }
-
-    if (!self.startCompleted) {
-        [self completeStart:NO token:self.activeToken];
-    }
-
+    if (self.stopInFlight) return [self waitForStopCompletion:5.0];
+    if (!self.isRecording && !self.session && !self.writer) return YES;
+    if (!self.startCompleted) [self completeStart:NO token:self.activeToken];
     self.stopInFlight = YES;
+    self.isRecording = NO;
+    [self nextToken]; // invalidate any queued startup work
 
     dispatch_semaphore_t stopSemaphore = dispatch_semaphore_create(0);
     self.stopSemaphore = stopSemaphore;
-
     dispatch_async(self.workQueue, ^{
-        // Stop video delegate
-        if (self.videoOutput) {
-            [self.videoOutput setSampleBufferDelegate:nil queue:nil];
-        }
-
-        // Finalize writer (audio_recorder.mm pattern)
-        if (self.writer && self.writerStarted) {
-            // LIP SYNC FIX: End session at stopLimit to trim excess frames
-            double stopLimit = MRSyncGetStopLimitSeconds();
-            if (stopLimit > 0) {
-                CMTime endTime = CMTimeMakeWithSeconds(stopLimit, 600);
-                [self.writer endSessionAtSourceTime:endTime];
-                MRLog(@"🎯 Camera writer session ended at %.3fs (stopLimit)", stopLimit);
+      @autoreleasepool {
+        @try {
+            @try {
+                if (self.videoOutput) [self.videoOutput setSampleBufferDelegate:nil queue:nil];
+            } @catch (NSException *exception) {
+                NSLog(@"[Recorder] Camera delegate detach failed safely: %@", exception.reason);
             }
-
-            if (self.writerInput) {
-                [self.writerInput markAsFinished];
+            // A callback already running may still use the writer/adaptor.
+            dispatch_sync(self.videoQueue, ^{});
+            MRFinishAssetWriterSafely(self.writer, 3.0, MRSyncGetStopLimitSeconds());
+            if (self.session.isRunning) [self.session stopRunning];
+            if (self.deviceInput && [self.session.inputs containsObject:self.deviceInput]) {
+                [self.session removeInput:self.deviceInput];
             }
-
-            dispatch_semaphore_t writerSemaphore = dispatch_semaphore_create(0);
-            [self.writer finishWritingWithCompletionHandler:^{
-                if (self.writer.status == AVAssetWriterStatusCompleted) {
-                    MRLog(@"✅ Camera writer finished");
-                } else if (self.writer.status == AVAssetWriterStatusFailed) {
-                    MRLog(@"❌ Camera writer failed: %@", self.writer.error);
-                }
-                dispatch_semaphore_signal(writerSemaphore);
-            }];
-
-            // 3 second timeout (matching audio_recorder.mm:269)
-            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
-            if (dispatch_semaphore_wait(writerSemaphore, timeout) != 0) {
-                MRLog(@"⚠️ Camera writer timeout – canceling");
-                [self.writer cancelWriting];
+            if (self.videoOutput && [self.session.outputs containsObject:self.videoOutput]) {
+                [self.session removeOutput:self.videoOutput];
             }
+        } @catch (NSException *exception) {
+            NSLog(@"[Recorder] Camera stop failed safely: %@", exception.reason);
+        } @finally {
+            [self cleanupAfterStopOnQueue];
+            // Signal only after the old session can no longer clear new state.
+            dispatch_semaphore_signal(stopSemaphore);
         }
-
-        dispatch_semaphore_signal(stopSemaphore);
-
-        // Session cleanup
-        if (self.session && [self.session isRunning]) {
-            [self.session stopRunning];
-        }
-
-        if (self.session && self.deviceInput && [self.session.inputs containsObject:self.deviceInput]) {
-            [self.session removeInput:self.deviceInput];
-        }
-        if (self.session && self.videoOutput && [self.session.outputs containsObject:self.videoOutput]) {
-            [self.session removeOutput:self.videoOutput];
-        }
-
-        [self cleanupAfterStopOnQueue];
+      }
     });
-
-    dispatch_time_t waitTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC));
-    long waitResult = dispatch_semaphore_wait(stopSemaphore, waitTime);
-    if (waitResult != 0) {
-        MRLog(@"⚠️ CameraRecorder: Stop did not finish within 5s (proceeding)");
-    } else {
-        MRLog(@"✅ CameraRecorder: Stop finalized");
-    }
-
-    self.stopSemaphore = nil;
-    self.isRecording = NO;
-    self.stopInFlight = NO;
-    return YES;
+    // A timeout does NOT release the stop-in-flight gate. A subsequent start
+    // must wait for this work queue to finish, especially after USB removal.
+    return [self waitForStopCompletion:5.0];
 }
 
 - (BOOL)waitForRecordingStartWithTimeout:(NSTimeInterval)timeout {
@@ -1022,6 +1004,15 @@ bool stopCameraRecording() {
     }
 }
 
+bool hasCameraRecordingResources() {
+    CameraRecorder *recorder = [CameraRecorder sharedRecorder];
+    return recorder.isRecording || recorder.stopInFlight || recorder.session != nil || recorder.writer != nil;
+}
+
+bool isCameraRecordingStopping() {
+    return [CameraRecorder sharedRecorder].stopInFlight;
+}
+
 bool isCameraRecording() {
     return [CameraRecorder sharedRecorder].isRecording;
 }