node-mac-recorder 2.21.2 → 2.21.4

package/.claude/settings.local.json

@@ -5,9 +5,12 @@
       "Bash(node:*)",
       "Bash(timeout:*)",
       "Bash(open:*)",
-      "Read(//Users/onur/codes/**)"
+      "Read(//Users/onur/codes/**)",
+      "Bash(log show:*)",
+      "Bash(MAC_RECORDER_DEBUG=1 node:*)",
+      "Read(//private/tmp/test-recording/**)"
     ],
     "deny": [],
     "ask": []
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.21.2",
+	"version": "2.21.4",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/camera_recorder.mm

@@ -82,6 +82,10 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 @property (atomic, assign) BOOL writerStarted;
 @property (atomic, assign) BOOL isShuttingDown;
 @property (nonatomic, assign) CMTime firstSampleTime;
+@property (nonatomic, assign) int32_t expectedWidth;
+@property (nonatomic, assign) int32_t expectedHeight;
+@property (nonatomic, assign) double expectedFrameRate;
+@property (atomic, assign) BOOL needsReconfiguration;
 
 + (instancetype)sharedRecorder;
 + (NSArray<NSDictionary *> *)availableCameraDevices;
@@ -105,34 +109,42 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 
 + (NSArray<NSDictionary *> *)availableCameraDevices {
     NSMutableArray<NSDictionary *> *devicesInfo = [NSMutableArray array];
-    
+
     NSMutableArray<AVCaptureDeviceType> *deviceTypes = [NSMutableArray array];
     BOOL allowContinuity = MRAllowContinuityCamera();
-    
+
+    // Always include built-in and external cameras
     if (@available(macOS 10.15, *)) {
         [deviceTypes addObject:AVCaptureDeviceTypeBuiltInWideAngleCamera];
     } else {
         [deviceTypes addObject:AVCaptureDeviceTypeBuiltInWideAngleCamera];
     }
-    
+
+    // ALWAYS add external cameras - they should be available regardless of Continuity permission
+    if (@available(macOS 14.0, *)) {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternal];
+    } else {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternalUnknown];
+    }
+
+    // Only add Continuity Camera type if allowed
     if (allowContinuity) {
         if (@available(macOS 14.0, *)) {
             [deviceTypes addObject:AVCaptureDeviceTypeContinuityCamera];
-            [deviceTypes addObject:AVCaptureDeviceTypeExternal];
-        } else {
-            [deviceTypes addObject:AVCaptureDeviceTypeExternalUnknown];
         }
     }
-    
+
     AVCaptureDeviceDiscoverySession *discoverySession =
         [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:deviceTypes
                                                                mediaType:AVMediaTypeVideo
                                                                 position:AVCaptureDevicePositionUnspecified];
-    
+
     for (AVCaptureDevice *device in discoverySession.devices) {
         BOOL continuityCamera = MRIsContinuityCamera(device);
+        // ONLY skip Continuity cameras when permission is missing
+        // Regular USB/external cameras should ALWAYS be listed
         if (continuityCamera && !allowContinuity) {
-            // Skip Continuity cameras when entitlement/env flag is missing
+            MRLog(@"⏭️ Skipping Continuity Camera (permission required): %@", device.localizedName);
             continue;
         }
         
@@ -242,23 +254,28 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     AVCaptureDeviceFormat *bestFormat = nil;
     int64_t bestResolutionScore = 0;
     double bestFrameRate = 0.0;
-    
+
+    MRLog(@"🔍 Scanning formats for device: %@", device.localizedName);
+
     for (AVCaptureDeviceFormat *format in device.formats) {
         CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
         if (dims.width <= 0 || dims.height <= 0) {
             continue;
         }
-        
+
+        // No filtering - use whatever the device supports
+        // The device knows best what it can capture
+
         int64_t score = (int64_t)dims.width * (int64_t)dims.height;
-        
+
         double maxFrameRate = 0.0;
         for (AVFrameRateRange *range in format.videoSupportedFrameRateRanges) {
             maxFrameRate = MAX(maxFrameRate, range.maxFrameRate);
         }
-        
+
         BOOL usesBetterResolution = score > bestResolutionScore;
         BOOL sameResolutionHigherFps = (score == bestResolutionScore) && (maxFrameRate > bestFrameRate);
-        
+
         if (!bestFormat || usesBetterResolution || sameResolutionHigherFps) {
             bestFormat = format;
             bestResolutionScore = score;
@@ -266,9 +283,17 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
             if (widthOut) *widthOut = dims.width;
             if (heightOut) *heightOut = dims.height;
             if (frameRateOut) *frameRateOut = bestFrameRate;
+            MRLog(@"   ✅ New best: %dx%d @ %.0ffps (score=%lld)",
+                  dims.width, dims.height, maxFrameRate, score);
         }
     }
-    
+
+    if (bestFormat) {
+        MRLog(@"📹 Selected format: %dx%d @ %.0ffps", *widthOut, *heightOut, *frameRateOut);
+    } else {
+        MRLog(@"❌ No suitable format found");
+    }
+
     return bestFormat;
 }
 
@@ -415,17 +440,28 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         MRLog(@"ℹ️ CameraRecorder: WebM unavailable, storing data in QuickTime container");
     }
     
-    NSInteger bitrate = (NSInteger)(width * height * 6); // Empirical bitrate multiplier
-    bitrate = MAX(bitrate, 5 * 1000 * 1000); // Minimum 5 Mbps
+    // Calculate bitrate based on resolution for high quality
+    // Use higher multiplier for better quality (10 instead of 6)
+    NSInteger bitrate = (NSInteger)(width * height * 10);
+    bitrate = MAX(bitrate, 8 * 1000 * 1000); // Minimum 8 Mbps for quality
+    bitrate = MIN(bitrate, 50 * 1000 * 1000); // Maximum 50 Mbps to avoid excessive file size
+
+    MRLog(@"🎬 Camera encoder settings: %dx%d @ %.2ffps, bitrate=%.2fMbps",
+          width, height, frameRate, bitrate / (1000.0 * 1000.0));
     
     NSMutableDictionary *compressionProps = [@{
         AVVideoAverageBitRateKey: @(bitrate),
         AVVideoMaxKeyFrameIntervalKey: @(MAX(1, (int)round(frameRate))),
-        AVVideoAllowFrameReorderingKey: @YES
+        AVVideoAllowFrameReorderingKey: @YES,
+        AVVideoExpectedSourceFrameRateKey: @(frameRate),
+        // Add quality hint for better encoding
+        AVVideoQualityKey: @(0.9) // 0.0-1.0, higher is better quality
     } mutableCopy];
-    
+
     if ([codec isEqualToString:AVVideoCodecTypeH264]) {
         compressionProps[AVVideoProfileLevelKey] = AVVideoProfileLevelH264HighAutoLevel;
+        // Use Main profile for better quality
+        compressionProps[AVVideoH264EntropyModeKey] = AVVideoH264EntropyModeCABAC;
     }
     
     NSDictionary *videoSettings = @{
@@ -440,9 +476,12 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     self.assetWriterInput.expectsMediaDataInRealTime = YES;
     
     NSDictionary *pixelBufferAttributes = @{
-        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange),
+        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange),
         (NSString *)kCVPixelBufferWidthKey: @(width),
-        (NSString *)kCVPixelBufferHeightKey: @(height)
+        (NSString *)kCVPixelBufferHeightKey: @(height),
+        // Preserve aspect ratio and use high quality scaling
+        (NSString *)kCVPixelBufferCGImageCompatibilityKey: @YES,
+        (NSString *)kCVPixelBufferCGBitmapContextCompatibilityKey: @YES
     };
     
     self.pixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:self.assetWriterInput
@@ -572,8 +611,10 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     
     self.videoOutput = [[AVCaptureVideoDataOutput alloc] init];
     self.videoOutput.alwaysDiscardsLateVideoFrames = NO;
+    // Use video range (not full range) for better compatibility and quality
+    // YpCbCr 4:2:0 biplanar is the native format for most cameras
     self.videoOutput.videoSettings = @{
-        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
+        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange)
     };
     
     self.captureQueue = dispatch_queue_create("node_mac_recorder.camera.queue", DISPATCH_QUEUE_SERIAL);
@@ -594,31 +635,39 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     
     AVCaptureConnection *connection = [self.videoOutput connectionWithMediaType:AVMediaTypeVideo];
     if (connection) {
-        if (connection.isVideoOrientationSupported) {
-            connection.videoOrientation = AVCaptureVideoOrientationPortrait;
-        }
+        // DON'T set orientation - let the camera use its natural orientation
+        // The device knows best (portrait for phones, landscape for webcams)
+        // We just capture whatever comes through
+
+        // Mirror front cameras for natural preview
         if (connection.isVideoMirroringSupported && device.position == AVCaptureDevicePositionFront) {
             if ([connection respondsToSelector:@selector(setAutomaticallyAdjustsVideoMirroring:)]) {
                 connection.automaticallyAdjustsVideoMirroring = NO;
             }
             connection.videoMirrored = YES;
         }
+
+        // Log actual connection properties for debugging
+        MRLog(@"📐 Camera connection: orientation=%ld (native), mirrored=%d, format=%dx%d",
+              (long)connection.videoOrientation,
+              connection.isVideoMirrored,
+              width, height);
     }
     
-    NSURL *outputURL = [NSURL fileURLWithPath:outputPath];
-    if (![self setupWriterWithURL:outputURL width:width height:height frameRate:frameRate error:error]) {
-        [self.session stopRunning];
-        [self resetState];
-        return NO;
-    }
-    
+    // DON'T setup writer yet - wait for first frame to get actual dimensions
+    // Store configuration for lazy initialization
     self.outputPath = outputPath;
     self.isRecording = YES;
     self.isShuttingDown = NO;
-    
+    self.expectedWidth = width;
+    self.expectedHeight = height;
+    self.expectedFrameRate = frameRate;
+    self.needsReconfiguration = NO;
+
     [self.session startRunning];
-    
-    MRLog(@"🎥 CameraRecorder started: %@ (%dx%d @ %.2ffps)", device.localizedName, width, height, frameRate);
+
+    MRLog(@"🎥 CameraRecorder started: %@ (will use actual frame dimensions)", device.localizedName);
+    MRLog(@"   Format reports: %dx%d @ %.2ffps", width, height, frameRate);
     return YES;
 }
 
@@ -674,18 +723,54 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     if (!self.isRecording || self.isShuttingDown) {
         return;
     }
-    
+
     if (!sampleBuffer) {
         return;
     }
-    
+
     CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+
+    // Lazy initialization - setup writer with actual frame dimensions
+    if (!self.assetWriter) {
+        CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+        if (!pixelBuffer) {
+            MRLog(@"❌ No pixel buffer in first frame");
+            return;
+        }
+
+        size_t actualWidth = CVPixelBufferGetWidth(pixelBuffer);
+        size_t actualHeight = CVPixelBufferGetHeight(pixelBuffer);
+
+        MRLog(@"🎬 First frame received: %zux%zu (format said %dx%d)",
+              actualWidth, actualHeight, self.expectedWidth, self.expectedHeight);
+
+        // Use ACTUAL dimensions from the frame, not format dimensions
+        NSURL *outputURL = [NSURL fileURLWithPath:self.outputPath];
+        NSError *setupError = nil;
+
+        // Use frame rate from device configuration
+        double frameRate = self.expectedFrameRate > 0 ? self.expectedFrameRate : 30.0;
+
+        if (![self setupWriterWithURL:outputURL
+                                width:(int32_t)actualWidth
+                               height:(int32_t)actualHeight
+                            frameRate:frameRate
+                                error:&setupError]) {
+            MRLog(@"❌ Failed to setup writer with actual dimensions: %@", setupError);
+            self.isRecording = NO;
+            return;
+        }
+
+        MRLog(@"✅ Writer configured with ACTUAL dimensions: %zux%zu", actualWidth, actualHeight);
+    }
+
     if (!self.writerStarted) {
         if (self.assetWriter.status == AVAssetWriterStatusUnknown) {
             if ([self.assetWriter startWriting]) {
                 [self.assetWriter startSessionAtSourceTime:timestamp];
                 self.writerStarted = YES;
                 self.firstSampleTime = timestamp;
+                MRLog(@"✅ Camera writer started");
             } else {
                 MRLog(@"❌ CameraRecorder: Failed to start asset writer: %@", self.assetWriter.error);
                 self.isRecording = NO;

package/src/screen_capture_kit.mm

@@ -120,31 +120,33 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 
 @implementation PureScreenCaptureDelegate
 - (void)stream:(SCStream * API_AVAILABLE(macos(12.3)))stream didStopWithError:(NSError *)error API_AVAILABLE(macos(12.3)) {
-    MRLog(@"🛑 Pure ScreenCapture stream stopped");
+    // ELECTRON FIX: Run cleanup on background thread to avoid blocking Electron
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        MRLog(@"🛑 Pure ScreenCapture stream stopped");
 
-    // Prevent recursive calls during cleanup
-    if (g_isCleaningUp) {
-        MRLog(@"⚠️ Already cleaning up, ignoring delegate callback");
-        return;
-    }
+        // Prevent recursive calls during cleanup
+        if (g_isCleaningUp) {
+            MRLog(@"⚠️ Already cleaning up, ignoring delegate callback");
+            return;
+        }
 
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        g_isRecording = NO;
-    }
+        @synchronized([ScreenCaptureKitRecorder class]) {
+            g_isRecording = NO;
+        }
 
-    if (error) {
-        NSLog(@"❌ Stream error: %@", error);
-    } else {
-        MRLog(@"✅ Stream stopped cleanly");
-    }
+        if (error) {
+            NSLog(@"❌ Stream error: %@", error);
+        } else {
+            MRLog(@"✅ Stream stopped cleanly");
+        }
 
-    // ELECTRON FIX: Don't use dispatch_async to main queue - it can cause crashes
-    // Instead, finalize directly on current thread with synchronization
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        if (!g_isCleaningUp) {
-            [ScreenCaptureKitRecorder finalizeRecording];
+        // Finalize on background thread with synchronization
+        @synchronized([ScreenCaptureKitRecorder class]) {
+            if (!g_isCleaningUp) {
+                [ScreenCaptureKitRecorder finalizeRecording];
+            }
         }
-    }
+    });
 }
 @end
 
@@ -460,16 +462,13 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         // Reset any stale state
         g_isCleaningUp = NO;
 
-        // Set flag early to prevent race conditions in Electron
-        g_isRecording = YES;
+        // DON'T set g_isRecording here - wait for stream to actually start
+        // This prevents the "recording=1 stream=null" issue
     }
 
     NSString *outputPath = config[@"outputPath"];
     if (!outputPath || [outputPath length] == 0) {
         NSLog(@"❌ Invalid output path provided");
-        @synchronized([ScreenCaptureKitRecorder class]) {
-            g_isRecording = NO;
-        }
         return NO;
     }
     g_outputPath = outputPath;
@@ -493,18 +492,17 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     MRLog(@"🔍 AUDIO DEBUG: includeMicrophone type=%@ value=%d", [includeMicrophone class], [includeMicrophone boolValue]);
     MRLog(@"🔍 AUDIO DEBUG: includeSystemAudio type=%@ value=%d", [includeSystemAudio class], [includeSystemAudio boolValue]);
 
-    // ELECTRON FIX: Get shareable content asynchronously without blocking
-    // This prevents deadlocks in Electron's event loop
-    [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
-        // This block runs asynchronously - safe for Electron
-        @autoreleasepool {
-        if (contentError) {
-            NSLog(@"❌ Content error: %@", contentError);
-            @synchronized([ScreenCaptureKitRecorder class]) {
-                g_isRecording = NO;
+    // ELECTRON FIX: Get shareable content FULLY ASYNCHRONOUSLY
+    // NO semaphores, NO blocking - pure async to prevent Electron crashes
+    // CRITICAL: Run on background queue to avoid blocking Electron's main thread
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
+            @autoreleasepool {
+            if (contentError) {
+                NSLog(@"❌ Content error: %@", contentError);
+                // No need to set g_isRecording=NO since it was never set to YES
+                return;  // Early return from completion handler block
             }
-            return;  // Early return from completion handler block
-        }
         
         MRLog(@"✅ Got %lu displays, %lu windows for pure recording", 
               content.displays.count, content.windows.count);
@@ -544,9 +542,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
                 recordingHeight = (NSInteger)targetWindow.frame.size.height;
             } else {
                 NSLog(@"❌ Window ID %@ not found", windowId);
-                @synchronized([ScreenCaptureKitRecorder class]) {
-                    g_isRecording = NO;
-                }
+                // No need to set g_isRecording=NO since it was never set to YES
                 return;  // Early return from completion handler block
             }
         }
@@ -576,9 +572,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             
             if (!targetDisplay) {
                 NSLog(@"❌ Display not found");
-                @synchronized([ScreenCaptureKitRecorder class]) {
-                    g_isRecording = NO;
-                }
+                // No need to set g_isRecording=NO since it was never set to YES
                 return;  // Early return from completion handler block
             }
             
@@ -681,9 +675,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         NSError *writerError = nil;
         if (![ScreenCaptureKitRecorder prepareVideoWriterWithWidth:recordingWidth height:recordingHeight error:&writerError]) {
             NSLog(@"❌ Failed to prepare video writer: %@", writerError);
-            @synchronized([ScreenCaptureKitRecorder class]) {
-                g_isRecording = NO;
-            }
+            // No need to set g_isRecording=NO since it was never set to YES
             return;  // Early return from completion handler block
         }
         
@@ -696,29 +688,30 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             g_audioStreamOutput = nil;
         }
         
+        // Create stream outputs and delegate
         g_streamDelegate = [[PureScreenCaptureDelegate alloc] init];
         g_stream = [[SCStream alloc] initWithFilter:filter configuration:streamConfig delegate:g_streamDelegate];
-        
+
+        // Check if stream was created successfully
         if (!g_stream) {
             NSLog(@"❌ Failed to create pure stream");
             CleanupWriters();
-            @synchronized([ScreenCaptureKitRecorder class]) {
-                g_isRecording = NO;
-            }
             return;  // Early return from completion handler block
         }
-        
+
+        MRLog(@"✅ Stream created successfully");
+
         NSError *outputError = nil;
         BOOL videoOutputAdded = [g_stream addStreamOutput:g_videoStreamOutput type:SCStreamOutputTypeScreen sampleHandlerQueue:g_videoQueue error:&outputError];
         if (!videoOutputAdded || outputError) {
             NSLog(@"❌ Failed to add video output: %@", outputError);
             CleanupWriters();
             @synchronized([ScreenCaptureKitRecorder class]) {
-                g_isRecording = NO;
+                g_stream = nil;
             }
             return;  // Early return from completion handler block
         }
-        
+
         if (g_shouldCaptureAudio) {
             if (@available(macOS 13.0, *)) {
                 NSError *audioError = nil;
@@ -727,7 +720,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
                     NSLog(@"❌ Failed to add audio output: %@", audioError);
                     CleanupWriters();
                     @synchronized([ScreenCaptureKitRecorder class]) {
-                        g_isRecording = NO;
+                        g_stream = nil;
                     }
                     return;  // Early return from completion handler block
                 }
@@ -736,27 +729,32 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
                 g_shouldCaptureAudio = NO;
             }
         }
-        
+
         MRLog(@"✅ Stream outputs configured (audio=%d)", g_shouldCaptureAudio);
         if (sessionTimestampNumber) {
             MRLog(@"🕒 Session timestamp: %@", sessionTimestampNumber);
         }
 
-        // ELECTRON FIX: Start capture asynchronously
+        // Start capture - can be async
         [g_stream startCaptureWithCompletionHandler:^(NSError *startError) {
             if (startError) {
                 NSLog(@"❌ Failed to start pure capture: %@", startError);
                 CleanupWriters();
                 @synchronized([ScreenCaptureKitRecorder class]) {
                     g_isRecording = NO;
+                    g_stream = nil;
                 }
             } else {
                 MRLog(@"🎉 PURE ScreenCaptureKit recording started successfully!");
-                // g_isRecording already set to YES at the beginning
+                // NOW set recording flag - stream is actually running
+                @synchronized([ScreenCaptureKitRecorder class]) {
+                    g_isRecording = YES;
+                }
             }
-        }];
+        }];  // End of startCaptureWithCompletionHandler
         }  // End of autoreleasepool
-    }];  // End of getShareableContentWithCompletionHandler
+        }];  // End of getShareableContentWithCompletionHandler
+    });  // End of dispatch_async
 
     // Return immediately - async completion will handle success/failure
     return YES;
@@ -773,22 +771,24 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     // Store stream reference to prevent it from being deallocated
     SCStream *streamToStop = g_stream;
 
-    // ELECTRON FIX: Stop asynchronously without blocking
+    // ELECTRON FIX: Stop FULLY ASYNCHRONOUSLY - NO blocking, NO semaphores
     [streamToStop stopCaptureWithCompletionHandler:^(NSError *stopError) {
-        if (stopError) {
-            NSLog(@"❌ Stop error: %@", stopError);
-        } else {
-            MRLog(@"✅ Pure stream stopped");
-        }
+        @autoreleasepool {
+            if (stopError) {
+                NSLog(@"❌ Stop error: %@", stopError);
+            } else {
+                MRLog(@"✅ Pure stream stopped");
+            }
 
-        // Reset recording state to allow new recordings
-        @synchronized([ScreenCaptureKitRecorder class]) {
-            g_isRecording = NO;
-        }
+            // Reset recording state to allow new recordings
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+            }
 
-        // Cleanup after stop completes
-        CleanupWriters();
-        [ScreenCaptureKitRecorder cleanupVideoWriter];
+            // Cleanup after stop completes
+            CleanupWriters();
+            [ScreenCaptureKitRecorder cleanupVideoWriter];
+        }
     }];
 }