node-mac-recorder 2.16.10 → 2.16.12

package/.claude/settings.local.json

@@ -1,7 +1,7 @@
 {
   "permissions": {
     "allow": [
-      "Bash(FORCE_AVFOUNDATION=1 node -e \"const MacRecorder = require(''./index.js''); const recorder = new MacRecorder(); recorder.checkPermissions().then(result => console.log(''Permission result (macOS 14 simulation):'', result))\")"
+      "Bash(FORCE_AVFOUNDATION=1 node -e \"\nconsole.log(''🧪 Testing fixed AVFoundation...'');\nconst MacRecorder = require(''./index.js'');\nconst recorder = new MacRecorder();\n\nrecorder.startRecording(''/tmp/electron-test2.mov'')\n  .then(success => {\n    console.log(''Start:'', success ? ''✅ SUCCESS'' : ''❌ FAILED'');\n    if (success) {\n      setTimeout(() => {\n        console.log(''⏹️ Stopping...'');\n        recorder.stopRecording().then(() => {\n          console.log(''✅ Stop completed'');\n          const fs = require(''fs'');\n          if (fs.existsSync(''/tmp/electron-test2.mov'')) {\n            console.log(''📹 File:'', Math.round(fs.statSync(''/tmp/electron-test2.mov'').size/1024) + ''KB'');\n            console.log(''🎉 Fix successful!'');\n          }\n        });\n      }, 2000);\n    }\n  })\n  .catch(console.error);\n\")"
     ],
     "deny": [],
     "ask": []

package/CLAUDE.md

@@ -4,11 +4,15 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-node-mac-recorder is a Node.js native addon that provides macOS screen recording capabilities using AVFoundation. The package allows recording of full screens, specific windows, or custom areas, with support for multi-display setups, audio capture, and cursor tracking.
+**ELECTRON-FIRST PRIORITY**: node-mac-recorder is a Node.js native addon specifically designed and optimized for Electron.js applications. It provides macOS screen recording capabilities using ScreenCaptureKit (macOS 15+) and AVFoundation (macOS 13+). The package allows recording of full screens, specific windows, or custom areas, with support for multi-display setups, audio capture, and cursor tracking.
+
+### **🚀 CRITICAL: Electron.js Support**
+This module is **PRIMARILY BUILT FOR ELECTRON.JS**. All features work seamlessly in Electron applications without any restrictions. Both ScreenCaptureKit and AVFoundation are fully supported in Electron environments.
 
 ## Build System & Commands
 
 ### Building the Native Module
+
 ```bash
 npm run build      # Build the native module using node-gyp
 npm run rebuild    # Clean rebuild of the native module
@@ -17,6 +21,7 @@ npm install        # Runs install.js which builds the module automatically
 ```
 
 ### Testing
+
 ```bash
 npm test           # Run the main test suite (test.js)
 node cursor-test.js # Test cursor tracking functionality only
@@ -24,7 +29,9 @@ node test.js       # Run comprehensive API tests
 ```
 
 ### Development
+
 The package uses node-gyp for building the native C++/Objective-C module. Requires:
+
 - macOS 10.15+ (Catalina or later)
 - Xcode Command Line Tools
 - Node.js 14+
@@ -34,16 +41,19 @@ The package uses node-gyp for building the native C++/Objective-C module. Requir
 ### Core Components
 
 **Main Entry Point**
+
 - `index.js` - Main MacRecorder class (EventEmitter-based)
 - Handles all high-level recording operations and coordinate transformations
 
 **Native Module** (`src/`)
+
 - `mac_recorder.mm` - Main native module entry point and N-API bindings
 - `screen_capture.mm` - AVFoundation-based screen/window recording
 - `audio_capture.mm` - Audio device enumeration and capture
 - `cursor_tracker.mm` - Real-time cursor position and event tracking
 
 **Build Configuration**
+
 - `binding.gyp` - Native module build configuration
 - Links against AVFoundation, ScreenCaptureKit, AppKit, and other macOS frameworks
 
@@ -58,6 +68,7 @@ The package uses node-gyp for building the native C++/Objective-C module. Requir
 ### Coordinate System Handling
 
 The package handles complex multi-display coordinate transformations:
+
 - Global macOS coordinates (can be negative for secondary displays)
 - Display-relative coordinates (always positive, 0-based)
 - Automatic window-to-display mapping for recording
@@ -65,6 +76,7 @@ The package handles complex multi-display coordinate transformations:
 ## API Structure
 
 ### Main Class Methods
+
 - `startRecording(outputPath, options)` - Begin screen/window recording
 - `stopRecording()` - Stop recording and finalize video file
 - `getWindows()` - List all recordable application windows
@@ -73,6 +85,7 @@ The package handles complex multi-display coordinate transformations:
 - `checkPermissions()` - Verify macOS recording permissions
 
 ### Cursor Tracking
+
 - `startCursorCapture(filepath, options)` - Begin real-time cursor tracking to JSON
   - `options.windowInfo` - Window information for window-relative coordinates
   - `options.windowRelative` - Set to true for window-relative coordinates
@@ -80,7 +93,9 @@ The package handles complex multi-display coordinate transformations:
 - `getCursorPosition()` - Get current cursor position and state
 
 ### Events
+
 The MacRecorder class emits the following events:
+
 - `recordingStarted` - Emitted immediately when recording starts with recording details
 - `started` - Emitted when recording is confirmed started (legacy event)
 - `stopped` - Emitted when recording stops
@@ -90,17 +105,20 @@ The MacRecorder class emits the following events:
 - `cursorCaptureStopped` - Emitted when cursor capture ends
 
 ### Thumbnails
+
 - `getWindowThumbnail(windowId, options)` - Capture window preview image
 - `getDisplayThumbnail(displayId, options)` - Capture display preview image
 
 ## Development Notes
 
 ### Testing Strategy
+
 - Use `npm test` for full API validation
 - `cursor-test.js` for testing cursor tracking specifically
 - Test files create output in `test-output/` directory
 
 ### Common Development Patterns
+
 - All recording operations are Promise-based
 - Event emission for recording state changes (`recordingStarted`, `started`, `stopped`, `completed`)
 - `recordingStarted` event provides immediate notification with recording details
@@ -111,12 +129,25 @@ The MacRecorder class emits the following events:
   - Display-relative coordinates (when recording)
   - Window-relative coordinates (with windowInfo parameter)
 
-### Platform Requirements
+### Platform Requirements & Framework Selection
+
+**ELECTRON-FIRST ARCHITECTURE:**
+- **Primary Target**: Electron.js applications (full support, no restrictions)
+- **Secondary**: Node.js standalone applications
 - macOS only (enforced in install.js)
 - Native module compilation required on install
 - Requires screen recording and accessibility permissions
 
+**Framework Selection Logic (Electron Priority):**
+- **macOS 15+ + Electron**: ScreenCaptureKit with full capabilities
+- **macOS 15+ + Node.js**: ScreenCaptureKit with full capabilities  
+- **macOS 14 + Electron**: AVFoundation with full capabilities
+- **macOS 13 + Electron**: AVFoundation with limited features
+- **macOS 14 + Node.js**: AVFoundation with full capabilities
+- **macOS 13 + Node.js**: AVFoundation with limited features
+
 ### File Outputs
+
 - Video recordings: `.mov` format (H.264/AAC)
 - Cursor data: JSON format with timestamped events
   - `x`, `y`: Cursor coordinates (coordinate system dependent)
@@ -131,14 +162,31 @@ The MacRecorder class emits the following events:
 ## Troubleshooting
 
 ### Build Issues
+
 1. Ensure Xcode Command Line Tools: `xcode-select --install`
 2. Clean rebuild: `npm run clean && npm run build`
 3. Check Node.js version compatibility (14+)
 
 ### Runtime Issues
+
 1. Permission failures: Check System Preferences > Security & Privacy
 2. Recording failures: Verify target windows/displays are accessible
 3. Audio issues: Check audio device availability and permissions
 
 ### Native Module Loading
-The module tries loading from `build/Release/` first, then falls back to `build/Debug/` with helpful error messages if neither exists.
+
+The module tries loading from `build/Release/` first, then falls back to `build/Debug/` with helpful error messages if neither exists.
+
+### **⚡ CRITICAL IMPLEMENTATION NOTES**
+
+**ELECTRON.JS IS THE PRIMARY TARGET:**
+1. **No Electron Restrictions**: All Electron detection logic is for optimization, NOT blocking
+2. **Framework Support**: Both ScreenCaptureKit and AVFoundation work perfectly in Electron
+3. **Environment Detection**: Code detects Electron to provide enhanced logging and optimization
+4. **macOS Compatibility**: 
+   - macOS 15+ (Sequoia+): Use ScreenCaptureKit for best performance
+   - macOS 14 (Sonoma): Use AVFoundation with full feature set
+   - macOS 13 (Ventura): Use AVFoundation with basic features
+5. **Error Handling**: Any "Recording failed to start" errors should trigger fallback logic, never blocking
+
+**NEVER BLOCK ELECTRON ENVIRONMENTS** - This is a core design principle.

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -123,7 +123,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         g_avCaptureRect = captureRect;
         g_avFrameNumber = 0;
         
-        // Start capture timer (15 FPS for compatibility)
+        // Start capture timer (10 FPS for Electron compatibility)
         dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
         g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
         
@@ -132,78 +132,107 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             return false;
         }
         
-        uint64_t interval = NSEC_PER_SEC / 15; // 15 FPS
+        uint64_t interval = NSEC_PER_SEC / 10; // 10 FPS for Electron stability
         dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, interval / 10);
         
         dispatch_source_set_event_handler(g_avTimer, ^{
             if (!g_avIsRecording) return;
             
             @autoreleasepool {
-                // Capture screen
-                CGImageRef screenImage = nil;
-                if (CGRectIsEmpty(g_avCaptureRect)) {
-                    screenImage = CGDisplayCreateImage(g_avDisplayID);
-                } else {
-                    CGImageRef fullScreen = CGDisplayCreateImage(g_avDisplayID);
-                    if (fullScreen) {
-                        screenImage = CGImageCreateWithImageInRect(fullScreen, g_avCaptureRect);
-                        CGImageRelease(fullScreen);
+                @try {
+                    // Capture screen with Electron-safe error handling
+                    CGImageRef screenImage = nil;
+                    if (CGRectIsEmpty(g_avCaptureRect)) {
+                        screenImage = CGDisplayCreateImage(g_avDisplayID);
+                    } else {
+                        CGImageRef fullScreen = CGDisplayCreateImage(g_avDisplayID);
+                        if (fullScreen) {
+                            screenImage = CGImageCreateWithImageInRect(fullScreen, g_avCaptureRect);
+                            CGImageRelease(fullScreen);
+                        }
                     }
-                }
-                
-                if (!screenImage) return;
-                
-                // Convert to pixel buffer
-                CVPixelBufferRef pixelBuffer = nil;
-                CVReturn cvRet = CVPixelBufferPoolCreatePixelBuffer(NULL, g_avPixelBufferAdaptor.pixelBufferPool, &pixelBuffer);
-                
-                if (cvRet == kCVReturnSuccess && pixelBuffer) {
-                    CVPixelBufferLockBaseAddress(pixelBuffer, 0);
-                    
-                    void *pixelData = CVPixelBufferGetBaseAddress(pixelBuffer);
-                    size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
-                    
-                    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
                     
-                    // Match bitmap info to pixel format for compatibility
-                    CGBitmapInfo bitmapInfo;
-                    OSType currentPixelFormat = CVPixelBufferGetPixelFormatType(pixelBuffer);
-                    if (currentPixelFormat == kCVPixelFormatType_32ARGB) {
-                        bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Big;
-                    } else { // kCVPixelFormatType_32BGRA
-                        bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little;
+                    if (!screenImage) {
+                        NSLog(@"⚠️ Failed to capture screen image, skipping frame");
+                        return;
                     }
+                
+                    // Convert to pixel buffer with Electron-safe error handling
+                    CVPixelBufferRef pixelBuffer = nil;
+                    CVReturn cvRet = CVPixelBufferPoolCreatePixelBuffer(NULL, g_avPixelBufferAdaptor.pixelBufferPool, &pixelBuffer);
                     
-                    CGContextRef context = CGBitmapContextCreate(pixelData, 
-                                                               CVPixelBufferGetWidth(pixelBuffer),
-                                                               CVPixelBufferGetHeight(pixelBuffer), 
-                                                               8, bytesPerRow, colorSpace, bitmapInfo);
-                    
-                    if (context) {
-                        CGContextDrawImage(context, CGRectMake(0, 0, CVPixelBufferGetWidth(pixelBuffer), CVPixelBufferGetHeight(pixelBuffer)), screenImage);
-                        CGContextRelease(context);
-                    }
-                    CGColorSpaceRelease(colorSpace);
-                    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
-                    
-                    // Write frame
-                    if (g_avVideoInput.readyForMoreMediaData) {
-                        CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(g_avFrameNumber / 15.0, 600));
-                        [g_avPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:frameTime];
-                        g_avFrameNumber++;
+                    if (cvRet == kCVReturnSuccess && pixelBuffer) {
+                        CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+                        
+                        void *pixelData = CVPixelBufferGetBaseAddress(pixelBuffer);
+                        if (!pixelData) {
+                            NSLog(@"⚠️ Failed to get pixel buffer base address");
+                            CVPixelBufferRelease(pixelBuffer);
+                            CGImageRelease(screenImage);
+                            return;
+                        }
+                        
+                        size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+                        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+                        if (!colorSpace) {
+                            NSLog(@"⚠️ Failed to create color space");
+                            CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+                            CVPixelBufferRelease(pixelBuffer);
+                            CGImageRelease(screenImage);
+                            return;
+                        }
+                        
+                        // Match bitmap info to pixel format for compatibility
+                        CGBitmapInfo bitmapInfo;
+                        OSType currentPixelFormat = CVPixelBufferGetPixelFormatType(pixelBuffer);
+                        if (currentPixelFormat == kCVPixelFormatType_32ARGB) {
+                            bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Big;
+                        } else { // kCVPixelFormatType_32BGRA
+                            bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little;
+                        }
+                        
+                        CGContextRef context = CGBitmapContextCreate(pixelData, 
+                                                                   CVPixelBufferGetWidth(pixelBuffer),
+                                                                   CVPixelBufferGetHeight(pixelBuffer), 
+                                                                   8, bytesPerRow, colorSpace, bitmapInfo);
+                        
+                        if (context) {
+                            CGContextDrawImage(context, CGRectMake(0, 0, CVPixelBufferGetWidth(pixelBuffer), CVPixelBufferGetHeight(pixelBuffer)), screenImage);
+                            CGContextRelease(context);
+                            
+                            // Write frame only if input is ready
+                            if (g_avVideoInput && g_avVideoInput.readyForMoreMediaData) {
+                                CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(g_avFrameNumber / 10.0, 600));
+                                BOOL appendSuccess = [g_avPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:frameTime];
+                                if (appendSuccess) {
+                                    g_avFrameNumber++;
+                                } else {
+                                    NSLog(@"⚠️ Failed to append pixel buffer");
+                                }
+                            }
+                        } else {
+                            NSLog(@"⚠️ Failed to create bitmap context");
+                        }
+                        
+                        CGColorSpaceRelease(colorSpace);
+                        CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+                        CVPixelBufferRelease(pixelBuffer);
+                    } else {
+                        NSLog(@"⚠️ Failed to create pixel buffer: %d", cvRet);
                     }
                     
-                    CVPixelBufferRelease(pixelBuffer);
+                    CGImageRelease(screenImage);
+                } @catch (NSException *exception) {
+                    NSLog(@"❌ Exception in AVFoundation capture loop: %@", exception.reason);
+                    g_avIsRecording = false; // Stop recording on exception to prevent crash
                 }
-                
-                CGImageRelease(screenImage);
             }
         });
         
         dispatch_resume(g_avTimer);
         g_avIsRecording = true;
         
-        NSLog(@"🎥 AVFoundation recording started: %dx%d @ 15fps", 
+        NSLog(@"🎥 AVFoundation recording started: %dx%d @ 10fps", 
               (int)recordingSize.width, (int)recordingSize.height);
         
         return true;
@@ -222,10 +251,11 @@ extern "C" bool stopAVFoundationRecording() {
     g_avIsRecording = false;
     
     @try {
-        // Stop timer
+        // Stop timer with Electron-safe cleanup
         if (g_avTimer) {
             dispatch_source_cancel(g_avTimer);
             g_avTimer = nil;
+            NSLog(@"✅ AVFoundation timer stopped safely");
         }
         
         // Finish writing

package/src/mac_recorder.mm

@@ -51,14 +51,8 @@ void cleanupRecording() {
         }
     }
     
-    // AVFoundation cleanup (only in non-Electron environments)
-    BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
-                      [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
-                     (NSProcessInfo.processInfo.processName && 
-                      [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
-                     (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
-    
-    if (!isElectron && isAVFoundationRecording()) {
+    // AVFoundation cleanup (supports both Node.js and Electron)
+    if (isAVFoundationRecording()) {
         stopAVFoundationRecording();
     }
     
@@ -211,10 +205,15 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             NSLog(@"🔧 FORCE_AVFOUNDATION environment variable detected - skipping ScreenCaptureKit");
         }
         
-        // ONLY use ScreenCaptureKit on macOS 15+
-        // macOS 14/13 ALWAYS use AVFoundation - NO ScreenCaptureKit attempts
-        if (isM15Plus && !forceAVFoundation && !isElectron) {
-            NSLog(@"✅ macOS 15+ detected - ScreenCaptureKit available with full compatibility");
+        // Electron-first priority: This application is built for Electron.js
+        // macOS 15+ → ScreenCaptureKit (including Electron)
+        // macOS 14/13 → AVFoundation (including Electron)
+        if (isM15Plus && !forceAVFoundation) {
+            if (isElectron) {
+                NSLog(@"⚡ ELECTRON PRIORITY: macOS 15+ Electron → ScreenCaptureKit with full support");
+            } else {
+                NSLog(@"✅ macOS 15+ Node.js → ScreenCaptureKit available with full compatibility");
+            }
             
             // Try ScreenCaptureKit with extensive safety measures
             @try {
@@ -288,25 +287,30 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             // If we reach here, ScreenCaptureKit failed, so fall through to AVFoundation
             NSLog(@"⏭️ ScreenCaptureKit failed - falling back to AVFoundation");
         } else {
-            // macOS 14/13 or forced AVFoundation - ALWAYS use AVFoundation
+            // macOS 14/13 or forced AVFoundation → ALWAYS use AVFoundation (Electron supported!)
             if (isElectron) {
-                NSLog(@"❌ Electron environment - Recording not supported");
-                return Napi::Boolean::New(env, false);
+                if (isM14Plus) {
+                    NSLog(@"⚡ ELECTRON PRIORITY: macOS 14/13 Electron → AVFoundation with full support");
+                } else if (isM13Plus) {
+                    NSLog(@"⚡ ELECTRON PRIORITY: macOS 13 Electron → AVFoundation with limited features");
+                }
+            } else {
+                if (isM15Plus) {
+                    NSLog(@"🎯 macOS 15+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
+                } else if (isM14Plus) {
+                    NSLog(@"🎯 macOS 14 Node.js → using AVFoundation (primary method)");
+                } else if (isM13Plus) {
+                    NSLog(@"🎯 macOS 13 Node.js → using AVFoundation (limited features)");  
+                }
             }
             
-            if (isM15Plus) {
-                NSLog(@"🎯 macOS 15+ with FORCE_AVFOUNDATION - using AVFoundation");
-            } else if (isM14Plus) {
-                NSLog(@"🎯 macOS 14 detected - using AVFoundation (primary method)");
-            } else if (isM13Plus) {
-                NSLog(@"🎯 macOS 13 detected - using AVFoundation (limited features)");  
-            } else {
+            if (!isM13Plus) {
                 NSLog(@"❌ macOS version too old (< 13.0) - Not supported");
                 return Napi::Boolean::New(env, false);
             }
             
-            // DIRECT AVFoundation - NO fallback logic needed
-            NSLog(@"⏭️ Using AVFoundation directly - no ScreenCaptureKit attempts");
+            // DIRECT AVFoundation for all environments (Node.js + Electron)
+            NSLog(@"⏭️ Using AVFoundation directly - supports both Node.js and Electron");
         }
         
         // AVFoundation recording (either fallback from ScreenCaptureKit or direct)
@@ -366,32 +370,26 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
         }
     }
     
-    // Try AVFoundation fallback (only in non-Electron environments)
-    BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
-                      [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
-                     (NSProcessInfo.processInfo.processName && 
-                      [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
-                     (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
+    // Try AVFoundation fallback (supports both Node.js and Electron)
+    extern bool isAVFoundationRecording();
+    extern bool stopAVFoundationRecording();
     
-    if (!isElectron) {
-        extern bool isAVFoundationRecording();
-        extern bool stopAVFoundationRecording();
-        
-        @try {
-            if (isAVFoundationRecording()) {
-                NSLog(@"🛑 Stopping AVFoundation recording");
-                if (stopAVFoundationRecording()) {
-                    g_isRecording = false;
-                    return Napi::Boolean::New(env, true);
-                } else {
-                    NSLog(@"❌ Failed to stop AVFoundation recording");
-                    g_isRecording = false;
-                    return Napi::Boolean::New(env, false);
-                }
+    @try {
+        if (isAVFoundationRecording()) {
+            NSLog(@"🛑 Stopping AVFoundation recording");
+            if (stopAVFoundationRecording()) {
+                g_isRecording = false;
+                return Napi::Boolean::New(env, true);
+            } else {
+                NSLog(@"❌ Failed to stop AVFoundation recording");
+                g_isRecording = false;
+                return Napi::Boolean::New(env, false);
             }
-        } @catch (NSException *exception) {
-            NSLog(@"❌ Exception stopping AVFoundation: %@", exception.reason);
         }
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception stopping AVFoundation: %@", exception.reason);
+        g_isRecording = false;
+        return Napi::Boolean::New(env, false);
     }
     
     NSLog(@"⚠️ No active recording found to stop");
@@ -662,14 +660,8 @@ Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
         }
     }
     
-    // Check AVFoundation only in non-Electron environments
-    BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
-                      [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
-                     (NSProcessInfo.processInfo.processName && 
-                      [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
-                     (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
-    
-    if (!isElectron && isAVFoundationRecording()) {
+    // Check AVFoundation (supports both Node.js and Electron)
+    if (isAVFoundationRecording()) {
         isRecording = true;
     }
     
@@ -935,8 +927,8 @@ Napi::Value CheckPermissions(const Napi::CallbackInfo& info) {
         NSLog(@"🔒 Permission check for macOS %ld.%ld.%ld", 
               (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
         
-        // Determine which framework will be used
-        BOOL willUseScreenCaptureKit = (isM15Plus && !forceAVFoundation && !isElectron);
+        // Determine which framework will be used (Electron fully supported!)
+        BOOL willUseScreenCaptureKit = (isM15Plus && !forceAVFoundation);  // Electron can use ScreenCaptureKit on macOS 15+
         BOOL willUseAVFoundation = (!willUseScreenCaptureKit && (isM13Plus || isM14Plus));
         
         if (willUseScreenCaptureKit) {