node-mac-recorder 2.21.21 → 2.21.23

package/electron-safe-index.js

@@ -44,8 +44,8 @@ class ElectronSafeMacRecorder extends EventEmitter {
 		this.options = {
 			includeMicrophone: false,
 			includeSystemAudio: false,
-			quality: "medium",
-			frameRate: 30,
+			quality: "high",
+			frameRate: 60,
 			captureArea: null,
 			captureCursor: false,
 			showClicks: false,

package/index.js

@@ -43,8 +43,8 @@ class MacRecorder extends EventEmitter {
 		this.options = {
 			includeMicrophone: false, // Default olarak mikrofon kapalı
 			includeSystemAudio: false, // Default olarak sistem sesi kapalı - kullanıcı explicit olarak açmalı
-			quality: "medium",
-			frameRate: 30,
+			quality: "high",
+			frameRate: 60,
 			captureArea: null, // { x, y, width, height }
 			captureCursor: false, // Default olarak cursor gizli
 			showClicks: false,
@@ -103,6 +103,7 @@ class MacRecorder extends EventEmitter {
 					position: device?.position ?? "unspecified",
 					transportType: device?.transportType ?? null,
 					isConnected: device?.isConnected ?? false,
+					isDefault: device?.isDefault === true,
 					hasFlash: device?.hasFlash ?? false,
 					supportsDepth: device?.supportsDepth ?? false,
 					deviceType: device?.deviceType ?? null,
@@ -180,6 +181,13 @@ class MacRecorder extends EventEmitter {
 		if (options.captureCamera !== undefined) {
 			this.options.captureCamera = options.captureCamera === true;
 		}
+		if (options.frameRate !== undefined) {
+			const fps = parseInt(options.frameRate, 10);
+			if (!Number.isNaN(fps) && fps > 0) {
+				// Clamp reasonable range 1-120
+				this.options.frameRate = Math.min(Math.max(fps, 1), 120);
+			}
+		}
 		if (options.cameraDeviceId !== undefined) {
 			this.options.cameraDeviceId =
 				typeof options.cameraDeviceId === "string" && options.cameraDeviceId.length > 0
@@ -496,6 +504,8 @@ class MacRecorder extends EventEmitter {
 					captureCamera: this.options.captureCamera === true,
 					cameraDeviceId: this.options.cameraDeviceId || null,
 					sessionTimestamp,
+					frameRate: this.options.frameRate || 60,
+					quality: this.options.quality || "high",
 				};
 
 					if (cameraFilePath) {

package/package.json

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

package/src/audio_recorder.mm

@@ -224,10 +224,30 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
         return YES;
     }
 
-    [self.session stopRunning];
+    // CRITICAL FIX: For external devices (especially Continuity Microphone),
+    // stopRunning can hang if device is disconnected. Use async approach.
+    MRLog(@"🛑 AudioRecorder: Stopping session (external device safe)...");
+
+    // Stop session on background thread to avoid blocking
+    AVCaptureSession *sessionToStop = self.session;
+    AVCaptureAudioDataOutput *outputToStop = self.audioOutput;
+
+    // Clear references FIRST to prevent new samples
     self.session = nil;
     self.audioOutput = nil;
 
+    // Stop session asynchronously with timeout protection
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        @autoreleasepool {
+            if ([sessionToStop isRunning]) {
+                MRLog(@"🛑 Stopping AVCaptureSession...");
+                [sessionToStop stopRunning];
+                MRLog(@"✅ AVCaptureSession stopped");
+            }
+            // 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
@@ -243,16 +263,16 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
             dispatch_semaphore_signal(semaphore);
         }];
 
-        // Reduced timeout to 2 seconds for faster response
-        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));
-        dispatch_semaphore_wait(semaphore, timeout);
+        // Reduced timeout to 1 second for external devices
+        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC));
+        long result = dispatch_semaphore_wait(semaphore, timeout);
 
-        if (!finished) {
-            MRLog(@"⚠️ AudioRecorder: Timed out waiting for writer to finish");
+        if (result != 0 || !finished) {
+            MRLog(@"⚠️ AudioRecorder: Timed out waiting for writer (external device?) - forcing cancel");
             // Force cancel if timeout
             [self.writer cancelWriting];
         } else {
-            MRLog(@"✅ AudioRecorder stopped successfully");
+            MRLog(@"✅ AudioRecorder writer finished successfully");
         }
     } else {
         MRLog(@"⚠️ AudioRecorder: No writer to finish (no audio captured)");
@@ -264,6 +284,7 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
     self.startTime = kCMTimeInvalid;
     self.outputPath = nil;
 
+    MRLog(@"✅ AudioRecorder stopped (safe for external devices)");
     return YES;
 }
 
@@ -334,11 +355,37 @@ NSArray<NSDictionary *> *listAudioCaptureDevices() {
                                position:AVCaptureDevicePositionUnspecified];
 
     for (AVCaptureDevice *device in session.devices) {
+        // PRIORITY FIX: MacBook built-in devices should be default, not external devices
+        // Check if this is a built-in device (MacBook's own microphone)
+        NSString *deviceName = device.localizedName ?: @"";
+        BOOL isBuiltIn = NO;
+
+        // Built-in detection: Check for "MacBook", "iMac", "Mac Studio", "Mac mini", "Mac Pro" in name
+        if ([deviceName rangeOfString:@"MacBook" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iMac" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Mac Studio" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Mac mini" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Mac Pro" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = YES;
+        }
+
+        // Also check for generic "Built-in" in name
+        if ([deviceName rangeOfString:@"Built-in" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = YES;
+        }
+
+        // External devices (Continuity, USB, etc.) should NOT be default
+        if ([deviceName rangeOfString:@"Continuity" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iPhone" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iPad" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = NO;
+        }
+
         NSDictionary *info = @{
             @"id": device.uniqueID ?: @"",
-            @"name": device.localizedName ?: @"Unknown Audio Device",
+            @"name": deviceName,
             @"manufacturer": device.manufacturer ?: @"",
-            @"isDefault": @(device.connected),
+            @"isDefault": @(isBuiltIn), // Only built-in devices are default
             @"transportType": @(device.transportType)
         };
         [devicesInfo addObject:info];

package/src/avfoundation_recorder.mm

@@ -34,7 +34,8 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                            bool includeMicrophone,
                                            bool includeSystemAudio,
                                            NSString* audioDeviceId,
-                                           NSString* audioOutputPath) {
+                                           NSString* audioOutputPath,
+                                           double requestedFrameRate) {
     
     if (g_avIsRecording) {
         NSLog(@"❌ AVFoundation recording already in progress");
@@ -129,15 +130,20 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         NSLog(@"🎬 ULTRA QUALITY AVFoundation: %dx%d, bitrate=%.2fMbps",
               (int)recordingSize.width, (int)recordingSize.height, bitrate / (1000.0 * 1000.0));
 
+        // Resolve target FPS
+        double fps = requestedFrameRate > 0 ? requestedFrameRate : 60.0;
+        if (fps < 1.0) fps = 1.0;
+        if (fps > 120.0) fps = 120.0;
+
         NSDictionary *videoSettings = @{
             AVVideoCodecKey: codecKey,
             AVVideoWidthKey: @((int)recordingSize.width),
             AVVideoHeightKey: @((int)recordingSize.height),
             AVVideoCompressionPropertiesKey: @{
                 AVVideoAverageBitRateKey: @(bitrate),
-                AVVideoMaxKeyFrameIntervalKey: @30,
+                AVVideoMaxKeyFrameIntervalKey: @((int)fps),
                 AVVideoAllowFrameReorderingKey: @YES,
-                AVVideoExpectedSourceFrameRateKey: @60,
+                AVVideoExpectedSourceFrameRateKey: @((int)fps),
                 AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better
                 AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
                 AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
@@ -266,7 +272,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             }
         }
 
-        // Start capture timer (10 FPS for Electron compatibility)
+        // Start capture timer using target FPS
         dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
         g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
         
@@ -275,7 +281,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             return false;
         }
         
-        uint64_t interval = NSEC_PER_SEC / 10; // 10 FPS for Electron stability
+        uint64_t interval = (uint64_t)(NSEC_PER_SEC / fps);
         dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, interval / 10);
         
         // Retain objects before passing to block to prevent deallocation
@@ -371,7 +377,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                             
                             // Write frame only if input is ready
                             if (localVideoInput && localVideoInput.readyForMoreMediaData) {
-                                CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(g_avFrameNumber / 10.0, 600));
+                                CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(((double)g_avFrameNumber) / fps, 600));
                                 BOOL appendSuccess = [localPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:frameTime];
                                 if (appendSuccess) {
                                     g_avFrameNumber++;
@@ -401,8 +407,8 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         dispatch_resume(g_avTimer);
         g_avIsRecording = true;
         
-        MRLog(@"🎥 AVFoundation recording started: %dx%d @ 10fps", 
-              (int)recordingSize.width, (int)recordingSize.height);
+        MRLog(@"🎥 AVFoundation recording started: %dx%d @ %.0ffps", 
+              (int)recordingSize.width, (int)recordingSize.height, fps);
         
         return true;
         

package/src/camera_recorder.mm

@@ -189,18 +189,58 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
                 position = @"unspecified";
                 break;
         }
-        
+
+        // PRIORITY FIX: MacBook built-in cameras should be default, not external cameras
+        // Check if this is a built-in camera (MacBook's own camera)
+        NSString *deviceName = device.localizedName ?: @"";
+        NSString *deviceType = device.deviceType ?: @"";
+        BOOL isBuiltIn = NO;
+
+        // Built-in detection: Check for common built-in camera names
+        if ([deviceName rangeOfString:@"FaceTime" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iSight" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Built-in" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = YES;
+        }
+
+        // Check device type for built-in wide angle camera
+        if (@available(macOS 10.15, *)) {
+            if ([deviceType isEqualToString:AVCaptureDeviceTypeBuiltInWideAngleCamera]) {
+                isBuiltIn = YES;
+            }
+        }
+
+        // External devices (Continuity Camera, iPhone, iPad, USB) should NOT be default
+        if (continuityCamera ||
+            [deviceName rangeOfString:@"iPhone" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iPad" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Continuity" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = NO;
+        }
+
+        // External device types should not be default
+        if (@available(macOS 14.0, *)) {
+            if ([deviceType isEqualToString:AVCaptureDeviceTypeExternal] ||
+                [deviceType isEqualToString:AVCaptureDeviceTypeContinuityCamera]) {
+                isBuiltIn = NO;
+            }
+        }
+        if ([deviceType isEqualToString:AVCaptureDeviceTypeExternalUnknown]) {
+            isBuiltIn = NO;
+        }
+
         NSDictionary *deviceInfo = @{
             @"id": device.uniqueID ?: @"",
-            @"name": device.localizedName ?: @"Unknown Camera",
+            @"name": deviceName,
             @"model": device.modelID ?: @"",
             @"manufacturer": device.manufacturer ?: @"",
             @"position": position ?: @"unspecified",
             @"transportType": @(device.transportType),
             @"isConnected": @(device.isConnected),
+            @"isDefault": @(isBuiltIn), // Only built-in cameras are default
             @"hasFlash": @(device.hasFlash),
             @"supportsDepth": @NO,
-            @"deviceType": device.deviceType ?: @"",
+            @"deviceType": deviceType,
             @"requiresContinuityCameraPermission": @(continuityCamera),
             @"maxResolution": @{
                 @"width": @(bestDimensions.width),
@@ -678,17 +718,33 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         return YES;
     }
 
+    // CRITICAL FIX: For external cameras (especially Continuity Camera/iPhone),
+    // stopRunning can hang if device is disconnected. Use async approach.
+    MRLog(@"🛑 CameraRecorder: Stopping session (external device safe)...");
+
     self.isShuttingDown = YES;
     self.isRecording = NO;
 
-    @try {
-        [self.session stopRunning];
-    } @catch (NSException *exception) {
-        MRLog(@"⚠️ CameraRecorder: Exception while stopping session: %@", exception.reason);
-    }
-
+    // Stop delegate FIRST to prevent new frames
     [self.videoOutput setSampleBufferDelegate:nil queue:nil];
 
+    // Stop session on background thread to avoid blocking
+    AVCaptureSession *sessionToStop = self.session;
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        @autoreleasepool {
+            @try {
+                if ([sessionToStop isRunning]) {
+                    MRLog(@"🛑 Stopping AVCaptureSession (camera)...");
+                    [sessionToStop stopRunning];
+                    MRLog(@"✅ AVCaptureSession stopped (camera)");
+                }
+            } @catch (NSException *exception) {
+                MRLog(@"⚠️ CameraRecorder: Exception while stopping session: %@", exception.reason);
+            }
+            // Release happens automatically when block completes
+        }
+    });
+
     // CRITICAL FIX: Check if assetWriter exists before trying to finish it
     // If no frames were captured, assetWriter will be nil
     if (!self.assetWriter) {
@@ -709,12 +765,12 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         dispatch_semaphore_signal(semaphore);
     }];
 
-    // Reduced timeout to 2 seconds for faster response
-    dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));
-    dispatch_semaphore_wait(semaphore, timeout);
+    // Reduced timeout to 1 second for external devices
+    dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC));
+    long result = dispatch_semaphore_wait(semaphore, timeout);
 
-    if (!finished) {
-        MRLog(@"⚠️ CameraRecorder: Timed out waiting for writer to finish");
+    if (result != 0 || !finished) {
+        MRLog(@"⚠️ CameraRecorder: Timed out waiting for writer (external device?) - forcing cancel");
         // Force cancel if timeout
         [self.assetWriter cancelWriting];
     }
@@ -723,10 +779,11 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     if (!success) {
         MRLog(@"⚠️ CameraRecorder: Writer finished with status %ld error %@", (long)self.assetWriter.status, self.assetWriter.error);
     } else {
-        MRLog(@"✅ CameraRecorder stopped successfully");
+        MRLog(@"✅ CameraRecorder writer finished successfully");
     }
 
     [self resetState];
+    MRLog(@"✅ CameraRecorder stopped (safe for external devices)");
     return success;
 }
 

package/src/electron_safe/screen_capture_electron.mm

@@ -121,12 +121,27 @@ static void initializeSafeQueue() {
             SCDisplay *targetDisplay = nil;
             
             if (displayId) {
+                // First, try matching by real CGDirectDisplayID
                 for (SCDisplay *display in content.displays) {
                     if (display.displayID == [displayId unsignedIntValue]) {
                         targetDisplay = display;
                         break;
                     }
                 }
+
+                // If not matched, treat provided value as index (0-based or 1-based)
+                if (!targetDisplay && content.displays.count > 0) {
+                    NSUInteger count = content.displays.count;
+                    NSUInteger idx0 = (NSUInteger)[displayId unsignedIntValue];
+                    if (idx0 < count) {
+                        targetDisplay = content.displays[idx0];
+                    } else if ([displayId unsignedIntegerValue] > 0) {
+                        NSUInteger idx1 = [displayId unsignedIntegerValue] - 1;
+                        if (idx1 < count) {
+                            targetDisplay = content.displays[idx1];
+                        }
+                    }
+                }
             }
             
             if (!targetDisplay && content.displays.count > 0) {
@@ -154,9 +169,45 @@ static void initializeSafeQueue() {
         }
         
         // Video configuration
-        config.width = 1920;
-        config.height = 1080;
-        config.minimumFrameInterval = CMTimeMake(1, 30); // 30 FPS
+        // Prefer the target display's native resolution when available
+        if (filter && [filter isKindOfClass:[SCContentFilter class]]) {
+            // Try to infer dimensions from selected display or capture area
+            NSDictionary *captureArea = options[@"captureArea"];
+            if (captureArea) {
+                config.width = (size_t)[captureArea[@"width"] doubleValue];
+                config.height = (size_t)[captureArea[@"height"] doubleValue];
+            } else {
+                // Find the selected display again to get dimensions
+                NSNumber *displayId = options[@"displayId"];
+                if (displayId) {
+                    for (SCDisplay *display in content.displays) {
+                        if (display.displayID == [displayId unsignedIntValue]) {
+                            config.width = (size_t)display.width;
+                            config.height = (size_t)display.height;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        
+        // Fallback default resolution if not set above
+        if (config.width == 0 || config.height == 0) {
+            config.width = 1920;
+            config.height = 1080;
+        }
+        
+        // Frame rate from options (default 60)
+        NSInteger fps = 60;
+        if (options[@"frameRate"]) {
+            NSInteger v = [options[@"frameRate"] integerValue];
+            if (v > 0) {
+                if (v < 1) v = 1;
+                if (v > 120) v = 120;
+                fps = v;
+            }
+        }
+        config.minimumFrameInterval = CMTimeMake(1, (int)fps);
         config.queueDepth = 8;
         
         // Capture area if specified

package/src/mac_recorder.mm

@@ -19,7 +19,8 @@ extern "C" {
                                    bool includeMicrophone,
                                    bool includeSystemAudio,
                                    NSString* audioDeviceId,
-                                   NSString* audioOutputPath);
+                                   NSString* audioOutputPath,
+                                   double frameRate);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
     NSString* getAVFoundationAudioPath();
@@ -204,6 +205,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     NSString *cameraOutputPath = nil;
     int64_t sessionTimestamp = 0;
     NSString *audioOutputPath = nil;
+    double frameRate = 60.0;
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
@@ -271,33 +273,57 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         if (options.Has("sessionTimestamp") && options.Get("sessionTimestamp").IsNumber()) {
             sessionTimestamp = options.Get("sessionTimestamp").As<Napi::Number>().Int64Value();
         }
+
+        // Frame rate
+        if (options.Has("frameRate") && options.Get("frameRate").IsNumber()) {
+            double fps = options.Get("frameRate").As<Napi::Number>().DoubleValue();
+            if (fps > 0) {
+                // Clamp to reasonable range
+                if (fps < 1.0) fps = 1.0;
+                if (fps > 120.0) fps = 120.0;
+                frameRate = fps;
+            }
+        }
         
-        // Display ID
+        // Display ID (accepts either real CGDirectDisplayID or index [0-based or 1-based])
         if (options.Has("displayId") && !options.Get("displayId").IsNull()) {
             double displayIdNum = options.Get("displayId").As<Napi::Number>().DoubleValue();
             
-            // Use the display ID directly (not as an index)
-            // The JavaScript layer passes the actual CGDirectDisplayID
-            displayID = (CGDirectDisplayID)displayIdNum;
+            // First, assume the provided value is a real CGDirectDisplayID
+            CGDirectDisplayID candidateID = (CGDirectDisplayID)displayIdNum;
             
-            // Verify that this display ID is valid
-            uint32_t displayCount;
+            // Verify against active displays
+            uint32_t displayCount = 0;
             CGGetActiveDisplayList(0, NULL, &displayCount);
             if (displayCount > 0) {
                 CGDirectDisplayID *displays = (CGDirectDisplayID*)malloc(displayCount * sizeof(CGDirectDisplayID));
                 CGGetActiveDisplayList(displayCount, displays, &displayCount);
                 
-                bool validDisplay = false;
+                bool matchedByID = false;
                 for (uint32_t i = 0; i < displayCount; i++) {
-                    if (displays[i] == displayID) {
-                        validDisplay = true;
+                    if (displays[i] == candidateID) {
+                        matchedByID = true;
+                        displayID = candidateID;
                         break;
                     }
                 }
                 
-                if (!validDisplay) {
-                    // Fallback to main display if invalid ID provided
-                    displayID = CGMainDisplayID();
+                if (!matchedByID) {
+                    // Tolerant mapping: allow passing index instead of CGDirectDisplayID
+                    // Try 0-based index
+                    int idx0 = (int)displayIdNum;
+                    if (idx0 >= 0 && idx0 < (int)displayCount) {
+                        displayID = displays[idx0];
+                    } else {
+                        // Try 1-based index (common in user examples)
+                        int idx1 = (int)displayIdNum - 1;
+                        if (idx1 >= 0 && idx1 < (int)displayCount) {
+                            displayID = displays[idx1];
+                        } else {
+                            // Fallback to main display
+                            displayID = CGMainDisplayID();
+                        }
+                    }
                 }
                 
                 free(displays);
@@ -400,6 +426,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                 if (sessionTimestamp != 0) {
                     sckConfig[@"sessionTimestamp"] = @(sessionTimestamp);
                 }
+                // Pass requested frame rate
+                sckConfig[@"frameRate"] = @(frameRate);
                 
                 if (!CGRectIsNull(captureRect)) {
                     sckConfig[@"captureRect"] = @{
@@ -511,7 +539,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                                                    bool includeMicrophone,
                                                    bool includeSystemAudio,
                                                    NSString* audioDeviceId,
-                                                   NSString* audioOutputPath);
+                                                   NSString* audioOutputPath,
+                                                   double frameRate);
 
             // CRITICAL SYNC FIX: Start camera BEFORE screen recording for perfect sync
             // This ensures both capture their first frame at approximately the same time
@@ -529,7 +558,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             // Now start screen recording immediately after camera
             MRLog(@"🎯 SYNC: Starting screen recording immediately");
             bool avResult = startAVFoundationRecording(outputPath, displayID, windowID, captureRect,
-                                                      captureCursor, includeMicrophone, includeSystemAudio, audioDeviceId, audioOutputPath);
+                                                      captureCursor, includeMicrophone, includeSystemAudio,
+                                                      audioDeviceId, audioOutputPath, frameRate);
 
             if (avResult) {
                 MRLog(@"🎥 RECORDING METHOD: AVFoundation");
@@ -827,6 +857,7 @@ Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
                 NSString *position = camera[@"position"];
                 NSNumber *transportType = camera[@"transportType"];
                 NSNumber *isConnected = camera[@"isConnected"];
+                NSNumber *isDefault = camera[@"isDefault"];
                 NSNumber *hasFlash = camera[@"hasFlash"];
                 NSNumber *supportsDepth = camera[@"supportsDepth"];
                 
@@ -861,7 +892,11 @@ Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
                 if (isConnected && [isConnected isKindOfClass:[NSNumber class]]) {
                     cameraObj.Set("isConnected", Napi::Boolean::New(env, [isConnected boolValue]));
                 }
-                
+
+                if (isDefault && [isDefault isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("isDefault", Napi::Boolean::New(env, [isDefault boolValue]));
+                }
+
                 if (hasFlash && [hasFlash isKindOfClass:[NSNumber class]]) {
                     cameraObj.Set("hasFlash", Napi::Boolean::New(env, [hasFlash boolValue]));
                 }

package/src/screen_capture_kit.mm

@@ -32,6 +32,7 @@ static BOOL g_audioWriterStarted = NO;
 
 static NSInteger g_configuredSampleRate = 48000;
 static NSInteger g_configuredChannelCount = 2;
+static NSInteger g_targetFPS = 60;
 
 // Frame rate debugging
 static NSInteger g_frameCount = 0;
@@ -342,9 +343,9 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 
     NSDictionary *compressionProps = @{
         AVVideoAverageBitRateKey: @(bitrate),
-        AVVideoMaxKeyFrameIntervalKey: @30,
+        AVVideoMaxKeyFrameIntervalKey: @(MAX(1, g_targetFPS)),
         AVVideoAllowFrameReorderingKey: @YES,
-        AVVideoExpectedSourceFrameRateKey: @60,
+        AVVideoExpectedSourceFrameRateKey: @(MAX(1, g_targetFPS)),
         AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better (0.95 = excellent)
         AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
         AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
@@ -524,6 +525,17 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     NSString *audioOutputPath = MRNormalizePath(config[@"audioOutputPath"]);
     NSNumber *sessionTimestampNumber = config[@"sessionTimestamp"];
     
+    // Extract requested frame rate
+    NSNumber *frameRateNumber = config[@"frameRate"];
+    if (frameRateNumber && [frameRateNumber respondsToSelector:@selector(intValue)]) {
+        NSInteger fps = [frameRateNumber intValue];
+        if (fps < 1) fps = 1;
+        if (fps > 120) fps = 120;
+        g_targetFPS = fps;
+    } else {
+        g_targetFPS = 60;
+    }
+    
     MRLog(@"🎬 Starting PURE ScreenCaptureKit recording (NO AVFoundation)");
     MRLog(@"🔧 Config: cursor=%@ mic=%@ system=%@ display=%@ window=%@ crop=%@", 
           captureCursor, includeMicrophone, includeSystemAudio, displayId, windowId, captureRect);
@@ -641,7 +653,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
         streamConfig.width = recordingWidth;
         streamConfig.height = recordingHeight;
-        streamConfig.minimumFrameInterval = CMTimeMake(1, 60); // 60 FPS for smooth recording
+        streamConfig.minimumFrameInterval = CMTimeMake(1, (int)MAX(1, g_targetFPS));
         streamConfig.pixelFormat = kCVPixelFormatType_32BGRA;
         streamConfig.scalesToFit = NO;
 
@@ -650,7 +662,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             streamConfig.queueDepth = 8; // Larger queue for smoother capture
         }
 
-        MRLog(@"🎬 ScreenCaptureKit config: %ldx%ld @ 60fps", (long)recordingWidth, (long)recordingHeight);
+        MRLog(@"🎬 ScreenCaptureKit config: %ldx%ld @ %ldfps", (long)recordingWidth, (long)recordingHeight, (long)g_targetFPS);
         
         BOOL shouldCaptureMic = includeMicrophone ? [includeMicrophone boolValue] : NO;
         BOOL shouldCaptureSystemAudio = includeSystemAudio ? [includeSystemAudio boolValue] : NO;
@@ -735,8 +747,8 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         BOOL shouldShowCursor = captureCursor ? [captureCursor boolValue] : YES;
         streamConfig.showsCursor = shouldShowCursor;
         
-        MRLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ 30fps, cursor=%d", 
-              recordingWidth, recordingHeight, shouldShowCursor);
+        MRLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ %ldfps, cursor=%d", 
+              recordingWidth, recordingHeight, (long)g_targetFPS, shouldShowCursor);
         
         NSError *writerError = nil;
         if (![ScreenCaptureKitRecorder prepareVideoWriterWithWidth:recordingWidth height:recordingHeight error:&writerError]) {