node-mac-recorder 2.21.40 → 2.21.42

package/src/screen_capture_kit.mm

@@ -6,40 +6,310 @@
 #import <CoreMedia/CoreMedia.h>
 #import <AudioToolbox/AudioToolbox.h>
 
-// Pure ScreenCaptureKit implementation - NO AVFoundation
+// MULTI-SESSION RECORDING: Session-based state management
+@interface RecordingSession : NSObject
+@property (nonatomic, strong) NSString *sessionId;
+@property (nonatomic, strong) SCStream *stream API_AVAILABLE(macos(12.3));
+@property (nonatomic, strong) id<SCStreamDelegate> streamDelegate API_AVAILABLE(macos(12.3));
+@property (nonatomic, assign) BOOL isRecording;
+@property (nonatomic, assign) BOOL isCleaningUp;
+@property (nonatomic, assign) BOOL isScheduling;
+@property (nonatomic, strong) NSString *outputPath;
+
+// Frame tracking
+@property (nonatomic, assign) BOOL firstFrameReceived;
+@property (nonatomic, assign) NSInteger frameCountSinceStart;
+
+// Queues and outputs
+@property (nonatomic, strong) dispatch_queue_t videoQueue;
+@property (nonatomic, strong) dispatch_queue_t audioQueue;
+@property (nonatomic, strong) id videoStreamOutput;
+@property (nonatomic, strong) id audioStreamOutput;
+
+// Video writer state
+@property (nonatomic, strong) AVAssetWriter *videoWriter;
+@property (nonatomic, strong) AVAssetWriterInput *videoInput;
+@property (nonatomic, assign) CFTypeRef pixelBufferAdaptorRef;
+@property (nonatomic, assign) CMTime videoStartTime;
+@property (nonatomic, assign) BOOL videoWriterStarted;
+
+// Audio state
+@property (nonatomic, assign) BOOL shouldCaptureAudio;
+@property (nonatomic, strong) NSString *audioOutputPath;
+@property (nonatomic, strong) AVAssetWriter *audioWriter;
+@property (nonatomic, strong) AVAssetWriterInput *systemAudioInput;
+@property (nonatomic, strong) AVAssetWriterInput *microphoneAudioInput;
+@property (nonatomic, assign) CMTime audioStartTime;
+@property (nonatomic, assign) BOOL audioWriterStarted;
+@property (nonatomic, assign) BOOL captureMicrophoneEnabled;
+@property (nonatomic, assign) BOOL captureSystemAudioEnabled;
+@property (nonatomic, assign) BOOL mixAudioEnabled;
+@property (nonatomic, assign) float mixMicGain;
+@property (nonatomic, assign) float mixSystemGain;
+
+// Configuration
+@property (nonatomic, assign) NSInteger configuredSampleRate;
+@property (nonatomic, assign) NSInteger configuredChannelCount;
+@property (nonatomic, assign) NSInteger targetFPS;
+
+// Frame rate debugging
+@property (nonatomic, assign) NSInteger frameCount;
+@property (nonatomic, assign) CFAbsoluteTime firstFrameTime;
+
+- (instancetype)initWithSessionId:(NSString *)sessionId;
+- (void)cleanup;
+@end
+
+@implementation RecordingSession
+
+- (instancetype)initWithSessionId:(NSString *)sessionId {
+    self = [super init];
+    if (self) {
+        _sessionId = sessionId;
+        _isRecording = NO;
+        _isCleaningUp = NO;
+        _isScheduling = NO;
+        _firstFrameReceived = NO;
+        _frameCountSinceStart = 0;
+        _videoStartTime = kCMTimeInvalid;
+        _videoWriterStarted = NO;
+        _audioStartTime = kCMTimeInvalid;
+        _audioWriterStarted = NO;
+        _shouldCaptureAudio = NO;
+        _captureMicrophoneEnabled = NO;
+        _captureSystemAudioEnabled = NO;
+        _mixAudioEnabled = YES;
+        _mixMicGain = 0.8f;
+        _mixSystemGain = 0.4f;
+        _configuredSampleRate = 48000;
+        _configuredChannelCount = 2;
+        _targetFPS = 60;
+        _frameCount = 0;
+        _firstFrameTime = 0;
+        _pixelBufferAdaptorRef = NULL;
+    }
+    return self;
+}
+
+- (void)cleanup {
+    MRLog(@"🧹 Cleaning up session: %@", _sessionId);
+
+    if (_pixelBufferAdaptorRef) {
+        CFRelease(_pixelBufferAdaptorRef);
+        _pixelBufferAdaptorRef = NULL;
+    }
+
+    _stream = nil;
+    _streamDelegate = nil;
+    _videoWriter = nil;
+    _videoInput = nil;
+    _audioWriter = nil;
+    _systemAudioInput = nil;
+    _microphoneAudioInput = nil;
+    _videoStreamOutput = nil;
+    _audioStreamOutput = nil;
+    _videoQueue = nil;
+    _audioQueue = nil;
+    _outputPath = nil;
+    _audioOutputPath = nil;
+    _isRecording = NO;
+    _isCleaningUp = NO;
+    _isScheduling = NO;
+    _firstFrameReceived = NO;
+    _frameCountSinceStart = 0;
+}
+
+- (void)dealloc {
+    [self cleanup];
+}
+
+@end
+
+// Session registry - thread-safe access
+static NSMutableDictionary<NSString *, RecordingSession *> *g_sessions = nil;
+static dispatch_queue_t g_sessionsQueue = nil;
+
+// Legacy global state for backward compatibility (points to first/default session)
 static SCStream * API_AVAILABLE(macos(12.3)) g_stream = nil;
 static id<SCStreamDelegate> API_AVAILABLE(macos(12.3)) g_streamDelegate = nil;
 static BOOL g_isRecording = NO;
-static BOOL g_isCleaningUp = NO;  // Prevent recursive cleanup
+static BOOL g_isCleaningUp = NO;
+static BOOL g_isScheduling = NO;
 static NSString *g_outputPath = nil;
-
+static BOOL g_firstFrameReceived = NO;
+static NSInteger g_frameCountSinceStart = 0;
 static dispatch_queue_t g_videoQueue = nil;
 static dispatch_queue_t g_audioQueue = nil;
 static id g_videoStreamOutput = nil;
 static id g_audioStreamOutput = nil;
-
 static AVAssetWriter *g_videoWriter = nil;
 static AVAssetWriterInput *g_videoInput = nil;
 static CFTypeRef g_pixelBufferAdaptorRef = NULL;
 static CMTime g_videoStartTime = kCMTimeInvalid;
 static BOOL g_videoWriterStarted = NO;
-
 static BOOL g_shouldCaptureAudio = NO;
 static NSString *g_audioOutputPath = nil;
 static AVAssetWriter *g_audioWriter = nil;
-static AVAssetWriterInput *g_audioInput = nil;
+static AVAssetWriterInput *g_systemAudioInput = nil;
+static AVAssetWriterInput *g_microphoneAudioInput = nil;
 static CMTime g_audioStartTime = kCMTimeInvalid;
 static BOOL g_audioWriterStarted = NO;
-
+static BOOL g_captureMicrophoneEnabled = NO;
+static BOOL g_captureSystemAudioEnabled = NO;
+static BOOL g_mixAudioEnabled = YES;
+static float g_mixMicGain = 0.8f;
+static float g_mixSystemGain = 0.4f;
 static NSInteger g_configuredSampleRate = 48000;
 static NSInteger g_configuredChannelCount = 2;
 static NSInteger g_targetFPS = 60;
-
-// Frame rate debugging
+static NSString *g_qualityPreset = @"high";
 static NSInteger g_frameCount = 0;
 static CFAbsoluteTime g_firstFrameTime = 0;
 
+// Quality helpers
+static NSString *SCKNormalizeQualityPreset(id preset) {
+    if (![preset isKindOfClass:[NSString class]]) {
+        return @"high";
+    }
+    NSString *trimmed = [[(NSString *)preset stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] lowercaseString];
+    if ([trimmed length] == 0) {
+        return @"high";
+    }
+    if ([trimmed isEqualToString:@"low"] || [trimmed isEqualToString:@"medium"] || [trimmed isEqualToString:@"high"]) {
+        return trimmed;
+    }
+    return @"high";
+}
+
+static CGFloat SCKQualityScaleForPreset(NSString *preset) {
+    NSString *normalized = SCKNormalizeQualityPreset(preset);
+    if ([normalized isEqualToString:@"low"]) {
+        return 0.5;
+    }
+    if ([normalized isEqualToString:@"medium"]) {
+        return 0.75;
+    }
+    return 1.0; // High = full resolution
+}
+
+static void SCKQualityBitrateForDimensions(NSString *preset,
+                                           NSInteger width,
+                                           NSInteger height,
+                                           NSInteger *bitrateOut,
+                                           NSInteger *multiplierOut,
+                                           NSInteger *minOut,
+                                           NSInteger *maxOut) {
+    NSString *normalized = SCKNormalizeQualityPreset(preset);
+
+    NSInteger multiplier = 30;
+    NSInteger minBitrate = 30 * 1000 * 1000;
+    NSInteger maxBitrate = 120 * 1000 * 1000;
+
+    if ([normalized isEqualToString:@"low"]) {
+        multiplier = 10;
+        minBitrate = 10 * 1000 * 1000;
+        maxBitrate = 45 * 1000 * 1000;
+    } else if ([normalized isEqualToString:@"medium"]) {
+        multiplier = 18;
+        minBitrate = 18 * 1000 * 1000;
+        maxBitrate = 80 * 1000 * 1000;
+    } else { // high/default
+        multiplier = 45;
+        minBitrate = 50 * 1000 * 1000;
+        maxBitrate = 200 * 1000 * 1000;
+    }
+
+    double base = ((double)MAX(1, width)) * ((double)MAX(1, height)) * (double)multiplier;
+    NSInteger bitrate = (NSInteger)base;
+    if (bitrate < minBitrate) bitrate = minBitrate;
+    if (bitrate > maxBitrate) bitrate = maxBitrate;
+
+    if (bitrateOut) *bitrateOut = bitrate;
+    if (multiplierOut) *multiplierOut = multiplier;
+    if (minOut) *minOut = minBitrate;
+    if (maxOut) *maxOut = maxBitrate;
+}
+
+static dispatch_queue_t ScreenCaptureControlQueue(void);
+static void SCKMarkSchedulingComplete(void);
+static void SCKFailScheduling(void);
+static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *content) API_AVAILABLE(macos(12.3));
+
 static void CleanupWriters(void);
+
+// SESSION MANAGEMENT FUNCTIONS
+static void InitializeSessionRegistry(void) {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        g_sessions = [[NSMutableDictionary alloc] init];
+        g_sessionsQueue = dispatch_queue_create("com.macrecorder.sessions", DISPATCH_QUEUE_CONCURRENT);
+        MRLog(@"📦 Session registry initialized");
+    });
+}
+
+static NSString *GenerateSessionId(void) {
+    return [NSString stringWithFormat:@"rec_%lld", (long long)([[NSDate date] timeIntervalSince1970] * 1000)];
+}
+
+static RecordingSession * _Nullable GetSession(NSString *sessionId) {
+    if (!sessionId) return nil;
+    InitializeSessionRegistry();
+
+    __block RecordingSession *session = nil;
+    dispatch_sync(g_sessionsQueue, ^{
+        session = g_sessions[sessionId];
+    });
+    return session;
+}
+
+static NSString *CreateSession(void) {
+    InitializeSessionRegistry();
+
+    NSString *sessionId = GenerateSessionId();
+    RecordingSession *session = [[RecordingSession alloc] initWithSessionId:sessionId];
+
+    dispatch_barrier_async(g_sessionsQueue, ^{
+        g_sessions[sessionId] = session;
+        MRLog(@"➕ Session created: %@", sessionId);
+    });
+
+    return sessionId;
+}
+
+static void RemoveSession(NSString *sessionId) {
+    if (!sessionId) return;
+    InitializeSessionRegistry();
+
+    dispatch_barrier_async(g_sessionsQueue, ^{
+        RecordingSession *session = g_sessions[sessionId];
+        if (session) {
+            [session cleanup];
+            [g_sessions removeObjectForKey:sessionId];
+            MRLog(@"➖ Session removed: %@", sessionId);
+        }
+    });
+}
+
+static NSArray<NSString *> *GetAllSessionIds(void) {
+    InitializeSessionRegistry();
+
+    __block NSArray<NSString *> *sessionIds = nil;
+    dispatch_sync(g_sessionsQueue, ^{
+        sessionIds = [g_sessions allKeys];
+    });
+    return sessionIds ?: @[];
+}
+
+static NSInteger GetActiveSessionCount(void) {
+    InitializeSessionRegistry();
+
+    __block NSInteger count = 0;
+    dispatch_sync(g_sessionsQueue, ^{
+        count = g_sessions.count;
+    });
+    return count;
+}
+
 static AVAssetWriterInputPixelBufferAdaptor * _Nullable CurrentPixelBufferAdaptor(void) {
     if (!g_pixelBufferAdaptorRef) {
         return nil;
@@ -103,17 +373,39 @@ static void CleanupWriters(void) {
     }
     
     if (g_audioWriter) {
-        FinishWriter(g_audioWriter, g_audioInput);
+        if (g_systemAudioInput) {
+            [g_systemAudioInput markAsFinished];
+        }
+        if (g_microphoneAudioInput) {
+            [g_microphoneAudioInput markAsFinished];
+        }
+        FinishWriter(g_audioWriter, nil);
         g_audioWriter = nil;
-        g_audioInput = nil;
+        g_systemAudioInput = nil;
+        g_microphoneAudioInput = nil;
         g_audioWriterStarted = NO;
         g_audioStartTime = kCMTimeInvalid;
+        g_captureMicrophoneEnabled = NO;
+        g_captureSystemAudioEnabled = NO;
     }
 }
 
 @interface PureScreenCaptureDelegate : NSObject <SCStreamDelegate>
 @end
 
+// External helpers for mixing/muxing
+extern "C" NSString *currentStandaloneAudioRecordingPath(void);
+extern "C" NSString *lastStandaloneAudioRecordingPath(void);
+extern "C" BOOL MRMixAudioToSingleTrack(NSString *primaryAudioPath,
+                                         NSString *externalMicPath,
+                                         BOOL preferInternalTracks);
+extern "C" BOOL MRMixAudioToSingleTrackWithGains(NSString *primaryAudioPath,
+                                                  NSString *externalMicPath,
+                                                  BOOL preferInternalTracks,
+                                                  float micGain,
+                                                  float systemGain);
+extern "C" BOOL MRMuxAudioIntoVideo(NSString *videoPath, NSString *audioPath);
+
 extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     if (!g_audioOutputPath) {
         return nil;
@@ -161,7 +453,8 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 @end
 
 @interface ScreenCaptureKitRecorder (Private)
-+ (BOOL)prepareAudioWriterIfNeededWithSampleBuffer:(CMSampleBufferRef)sampleBuffer;
++ (BOOL)prepareAudioWriterIfNeededWithSampleBuffer:(CMSampleBufferRef)sampleBuffer
+                                     isMicrophone:(BOOL)isMicrophone;
 @end
 
 @interface ScreenCaptureVideoOutput : NSObject <SCStreamOutput>
@@ -182,6 +475,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     }
     
     CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+    MRSyncMarkAudioSample(presentationTime);
     
     // Wait for audio to arrive before starting screen video to prevent leading frames.
     if (MRSyncShouldHoldVideoFrame(presentationTime)) {
@@ -196,8 +490,18 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         [g_videoWriter startSessionAtSourceTime:kCMTimeZero];
         g_videoStartTime = presentationTime;
         g_videoWriterStarted = YES;
+        g_frameCountSinceStart = 0;
         MRLog(@"🎞️ Video writer session started @ %.3f (zero-based timeline)", CMTimeGetSeconds(presentationTime));
     }
+
+    // ELECTRON FIX: Track frame count to ensure ScreenCaptureKit is fully running
+    if (!g_firstFrameReceived) {
+        g_frameCountSinceStart++;
+        if (g_frameCountSinceStart >= 10) {  // Wait for 10 frames (~150ms at 60fps)
+            g_firstFrameReceived = YES;
+            MRLog(@"✅ ScreenCaptureKit fully initialized after %ld frames", (long)g_frameCountSinceStart);
+        }
+    }
     
     if (!g_videoInput.readyForMoreMediaData) {
         return;
@@ -234,6 +538,18 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             relativePresentation = kCMTimeZero;
         }
     }
+
+    double stopLimit = MRSyncGetStopLimitSeconds();
+    if (stopLimit > 0) {
+        double frameSeconds = CMTimeGetSeconds(relativePresentation);
+        double tolerance = g_targetFPS > 0 ? (1.5 / g_targetFPS) : 0.02;
+        if (tolerance < 0.02) {
+            tolerance = 0.02;
+        }
+        if (frameSeconds > stopLimit + tolerance) {
+            return;
+        }
+    }
     
     AVAssetWriterInputPixelBufferAdaptor *adaptor = adaptorCandidate;
     BOOL appended = [adaptor appendPixelBuffer:pixelBuffer withPresentationTime:relativePresentation];
@@ -268,24 +584,50 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         return;
     }
 
-    if (@available(macOS 13.0, *)) {
-        if (type != SCStreamOutputTypeAudio) {
-            return;
+    BOOL isMicrophoneSample = NO;
+    BOOL isSupportedSample = NO;
+    if (@available(macOS 15.0, *)) {
+        if (type == SCStreamOutputTypeAudio) {
+            isSupportedSample = YES;
+        } else if (type == SCStreamOutputTypeMicrophone) {
+            isSupportedSample = YES;
+            isMicrophoneSample = YES;
         }
-    } else {
+    } else if (@available(macOS 13.0, *)) {
+        if (type == SCStreamOutputTypeAudio) {
+            isSupportedSample = YES;
+        }
+    }
+
+    if (!isSupportedSample) {
         return;
     }
 
+    BOOL routeToMicrophoneTrack = isMicrophoneSample;
+    if (!routeToMicrophoneTrack) {
+        if (!g_captureSystemAudioEnabled && g_captureMicrophoneEnabled) {
+            // Only microphone requested (e.g., macOS < 15), so treat stream as microphone.
+            routeToMicrophoneTrack = YES;
+        }
+    }
+
     if (!CMSampleBufferDataIsReady(sampleBuffer)) {
-        MRLog(@"⚠️ Audio sample buffer data not ready");
+        MRLog(@"⚠️ %@ audio sample buffer not ready",
+              routeToMicrophoneTrack ? @"Microphone" : @"System");
         return;
     }
     
-    if (![ScreenCaptureKitRecorder prepareAudioWriterIfNeededWithSampleBuffer:sampleBuffer]) {
+    if (![ScreenCaptureKitRecorder prepareAudioWriterIfNeededWithSampleBuffer:sampleBuffer
+                                                                 isMicrophone:routeToMicrophoneTrack]) {
         return;
     }
     
-    if (!g_audioWriter || !g_audioInput) {
+    if (!g_audioWriter) {
+        return;
+    }
+
+    AVAssetWriterInput *targetInput = routeToMicrophoneTrack ? g_microphoneAudioInput : g_systemAudioInput;
+    if (!targetInput) {
         return;
     }
     
@@ -299,13 +641,20 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         [g_audioWriter startSessionAtSourceTime:kCMTimeZero];
         g_audioStartTime = presentationTime;
         g_audioWriterStarted = YES;
-        MRLog(@"🔊 Audio writer session started @ %.3f (zero-based timeline)", CMTimeGetSeconds(presentationTime));
+        MRLog(@"🔊 Audio writer session started @ %.3f (source=%@)",
+              CMTimeGetSeconds(presentationTime),
+              routeToMicrophoneTrack ? @"microphone" : @"system");
     }
     
-    if (!g_audioInput.readyForMoreMediaData) {
-        static int notReadyCount = 0;
-        if (notReadyCount++ % 100 == 0) {
-            MRLog(@"⚠️ Audio input not ready for data (count: %d)", notReadyCount);
+    static int systemNotReadyCount = 0;
+    static int microphoneNotReadyCount = 0;
+    int *notReadyCounter = routeToMicrophoneTrack ? &microphoneNotReadyCount : &systemNotReadyCount;
+
+    if (!targetInput.readyForMoreMediaData) {
+        if ((*notReadyCounter)++ % 100 == 0) {
+            MRLog(@"⚠️ %@ audio input not ready for data (count: %d)",
+                  routeToMicrophoneTrack ? @"Microphone" : @"System",
+                  *notReadyCounter);
         }
         return;
     }
@@ -362,13 +711,34 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         }
     }
     
-    BOOL success = [g_audioInput appendSampleBuffer:bufferToAppend];
+    double stopLimit = MRSyncGetStopLimitSeconds();
+    if (stopLimit > 0) {
+        CMTime sampleStart = CMSampleBufferGetPresentationTimeStamp(bufferToAppend);
+        double sampleSeconds = CMTimeGetSeconds(sampleStart);
+        double sampleDuration = CMTIME_IS_VALID(CMSampleBufferGetDuration(bufferToAppend))
+                              ? CMTimeGetSeconds(CMSampleBufferGetDuration(bufferToAppend))
+                              : 0.0;
+        double tolerance = 0.02;
+        if (sampleSeconds > stopLimit + tolerance ||
+            (sampleDuration > 0.0 && (sampleSeconds + sampleDuration) > stopLimit + tolerance)) {
+            if (bufferToAppend != sampleBuffer) {
+                CFRelease(bufferToAppend);
+            }
+            return;
+        }
+    }
+
+    BOOL success = [targetInput appendSampleBuffer:bufferToAppend];
     if (!success) {
         NSLog(@"⚠️ Failed appending audio sample buffer: %@", g_audioWriter.error);
     } else {
-        static int appendCount = 0;
-        if (appendCount++ % 100 == 0) {
-            MRLog(@"✅ Audio sample appended successfully (count: %d)", appendCount);
+        static int systemAppendCount = 0;
+        static int microphoneAppendCount = 0;
+        int *appendCount = routeToMicrophoneTrack ? &microphoneAppendCount : &systemAppendCount;
+        if ((*appendCount)++ % 100 == 0) {
+            MRLog(@"✅ %@ audio sample appended (count: %d)",
+                  routeToMicrophoneTrack ? @"Microphone" : @"System",
+                  *appendCount);
         }
     }
     
@@ -400,23 +770,35 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         return NO;
     }
     
-    // QUALITY FIX: ULTRA HIGH quality for screen recording
-    // ProMotion displays may run at 10Hz (low power) = 10 FPS capture
-    // Solution: Use VERY HIGH bitrate so each frame is perfect quality
-    // Use 30x multiplier for ULTRA quality (was 6x - way too low!)
-    NSInteger bitrate = (NSInteger)(width * height * 30);
-    bitrate = MAX(bitrate, 30 * 1000 * 1000);  // Minimum 30 Mbps for crystal clear screen recording
-    bitrate = MIN(bitrate, 120 * 1000 * 1000); // Maximum 120 Mbps for ultra quality
+    NSInteger bitrate = 0;
+    NSInteger bitrateMultiplier = 0;
+    NSInteger minBitrate = 0;
+    NSInteger maxBitrate = 0;
+    NSString *normalizedQuality = SCKNormalizeQualityPreset(g_qualityPreset);
+    SCKQualityBitrateForDimensions(normalizedQuality, width, height, &bitrate, &bitrateMultiplier, &minBitrate, &maxBitrate);
+
+    NSNumber *qualityHint = @0.95;
+    if ([normalizedQuality isEqualToString:@"medium"]) {
+        qualityHint = @0.9;
+    } else if ([normalizedQuality isEqualToString:@"low"]) {
+        qualityHint = @0.85;
+    }
 
-    MRLog(@"🎬 ULTRA QUALITY Screen encoder: %ldx%ld, bitrate=%.2fMbps",
-          (long)width, (long)height, bitrate / (1000.0 * 1000.0));
+    MRLog(@"🎬 Screen encoder (%@): %ldx%ld, multiplier=%ld, bitrate=%.2fMbps (min=%ldMbps max=%ldMbps)",
+          normalizedQuality,
+          (long)width,
+          (long)height,
+          (long)bitrateMultiplier,
+          bitrate / (1000.0 * 1000.0),
+          (long)(minBitrate / (1000 * 1000)),
+          (long)(maxBitrate / (1000 * 1000)));
 
     NSDictionary *compressionProps = @{
         AVVideoAverageBitRateKey: @(bitrate),
         AVVideoMaxKeyFrameIntervalKey: @(MAX(1, g_targetFPS)),
         AVVideoAllowFrameReorderingKey: @YES,
         AVVideoExpectedSourceFrameRateKey: @(MAX(1, g_targetFPS)),
-        AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better (0.95 = excellent)
+        AVVideoQualityKey: qualityHint,  // 0.0-1.0, higher is better
         AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
         AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
     };
@@ -462,61 +844,135 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     return YES;
 }
 
-+ (BOOL)prepareAudioWriterIfNeededWithSampleBuffer:(CMSampleBufferRef)sampleBuffer {
-    if (!g_shouldCaptureAudio || g_audioWriter || !g_audioOutputPath) {
++ (BOOL)prepareAudioWriterIfNeededWithSampleBuffer:(CMSampleBufferRef)sampleBuffer
+                                     isMicrophone:(BOOL)isMicrophone {
+    if (!g_shouldCaptureAudio || !g_audioOutputPath) {
         return g_audioWriter != nil || !g_shouldCaptureAudio;
     }
-    
+
     CMFormatDescriptionRef formatDescription = CMSampleBufferGetFormatDescription(sampleBuffer);
     if (!formatDescription) {
         NSLog(@"⚠️ Missing audio format description");
         return NO;
     }
-    
-    const AudioStreamBasicDescription *asbd = CMAudioFormatDescriptionGetStreamBasicDescription(formatDescription);
+
+    const AudioStreamBasicDescription *asbd =
+        CMAudioFormatDescriptionGetStreamBasicDescription(formatDescription);
     if (!asbd) {
         NSLog(@"⚠️ Unsupported audio format description");
         return NO;
     }
-    
-    g_configuredSampleRate = (NSInteger)asbd->mSampleRate;
-    g_configuredChannelCount = asbd->mChannelsPerFrame;
-    
-    NSString *originalPath = g_audioOutputPath ?: @"";
-    NSURL *audioURL = [NSURL fileURLWithPath:originalPath];
-    [[NSFileManager defaultManager] removeItemAtURL:audioURL error:nil];
-    
-    NSError *writerError = nil;
-    // CRITICAL FIX: AVAssetWriter does NOT support WebM for audio
-    // Always use QuickTime Movie format (.mov) for audio files
-    AVFileType requestedFileType = AVFileTypeQuickTimeMovie;
-
-    // Ensure path has .mov extension for audio
-    NSString *audioPath = originalPath;
-    if (![audioPath.pathExtension.lowercaseString isEqualToString:@"mov"]) {
-        MRLog(@"⚠️ Audio path has wrong extension '%@', changing to .mov", audioPath.pathExtension);
-        audioPath = [[audioPath stringByDeletingPathExtension] stringByAppendingPathExtension:@"mov"];
-        g_audioOutputPath = audioPath;
-    }
-    audioURL = [NSURL fileURLWithPath:audioPath];
-    [[NSFileManager defaultManager] removeItemAtURL:audioURL error:nil];
-
-    @try {
-        g_audioWriter = [[AVAssetWriter alloc] initWithURL:audioURL fileType:requestedFileType error:&writerError];
-    } @catch (NSException *exception) {
-        NSDictionary *info = @{
-            NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize audio writer"
-        };
-        writerError = [NSError errorWithDomain:@"ScreenCaptureKitRecorder" code:-201 userInfo:info];
-        g_audioWriter = nil;
+
+    if (!g_audioWriter) {
+        g_configuredSampleRate = (NSInteger)asbd->mSampleRate;
+        g_configuredChannelCount = asbd->mChannelsPerFrame;
+
+        NSString *originalPath = g_audioOutputPath ?: @"";
+        NSURL *audioURL = [NSURL fileURLWithPath:originalPath];
+        [[NSFileManager defaultManager] removeItemAtURL:audioURL error:nil];
+
+        NSError *writerError = nil;
+        AVFileType requestedFileType = AVFileTypeQuickTimeMovie;
+
+        NSString *audioPath = originalPath;
+        if (![audioPath.pathExtension.lowercaseString isEqualToString:@"mov"]) {
+            MRLog(@"⚠️ Audio path has wrong extension '%@', changing to .mov", audioPath.pathExtension);
+            audioPath = [[audioPath stringByDeletingPathExtension] stringByAppendingPathExtension:@"mov"];
+            g_audioOutputPath = audioPath;
+        }
+        audioURL = [NSURL fileURLWithPath:audioPath];
+        [[NSFileManager defaultManager] removeItemAtURL:audioURL error:nil];
+
+        @try {
+            g_audioWriter = [[AVAssetWriter alloc] initWithURL:audioURL
+                                                      fileType:requestedFileType
+                                                         error:&writerError];
+        } @catch (NSException *exception) {
+            NSDictionary *info = @{
+                NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize audio writer"
+            };
+            writerError = [NSError errorWithDomain:@"ScreenCaptureKitRecorder" code:-201 userInfo:info];
+            g_audioWriter = nil;
+        }
+
+        if (!g_audioWriter || writerError) {
+            NSLog(@"❌ Failed to create audio writer: %@", writerError);
+            return NO;
+        }
+
+        // Reset tracking flags whenever we create a new writer
+        g_audioWriterStarted = NO;
+        g_audioStartTime = kCMTimeInvalid;
+
+        // CRITICAL FIX: Add BOTH system and microphone inputs NOW (before startWriting)
+        // if both are enabled. AVAssetWriter cannot add inputs after startWriting() is called.
+        NSLog(@"🎙️ Creating audio writer - system=%d, microphone=%d",
+              g_captureSystemAudioEnabled, g_captureMicrophoneEnabled);
     }
-    
-    if (!g_audioWriter || writerError) {
-        NSLog(@"❌ Failed to create audio writer: %@", writerError);
-        return NO;
+
+    AVAssetWriterInput **targetInput = isMicrophone ? &g_microphoneAudioInput : &g_systemAudioInput;
+    if (*targetInput) {
+        return YES;
     }
-    
-    NSInteger channelCount = MAX(1, g_configuredChannelCount);
+
+    // If writer was just created and BOTH sources are enabled, create BOTH inputs now
+    if (g_audioWriter && g_captureSystemAudioEnabled && g_captureMicrophoneEnabled) {
+        if (!g_systemAudioInput && !g_microphoneAudioInput) {
+            NSLog(@"🎙️ Both audio sources enabled - creating both inputs from first sample");
+
+            NSUInteger channelCount = MAX((NSUInteger)1, (NSUInteger)asbd->mChannelsPerFrame);
+            AudioChannelLayout layout = {0};
+            size_t layoutSize = 0;
+            if (channelCount == 1) {
+                layout.mChannelLayoutTag = kAudioChannelLayoutTag_Mono;
+                layoutSize = sizeof(AudioChannelLayout);
+            } else if (channelCount == 2) {
+                layout.mChannelLayoutTag = kAudioChannelLayoutTag_Stereo;
+                layoutSize = sizeof(AudioChannelLayout);
+            }
+
+            NSMutableDictionary *audioSettings = [@{
+                AVFormatIDKey: @(kAudioFormatMPEG4AAC),
+                AVSampleRateKey: @(asbd->mSampleRate),
+                AVNumberOfChannelsKey: @(channelCount),
+                AVEncoderBitRateKey: @(192000)
+            } mutableCopy];
+
+            if (layoutSize > 0) {
+                audioSettings[AVChannelLayoutKey] = [NSData dataWithBytes:&layout length:layoutSize];
+            }
+
+            // ELECTRON FIX: Create microphone input FIRST (stream 0)
+            // Electron plays stream 0 by default, so put the more important audio first
+            // TODO: Mix both streams into single track for full Electron compatibility
+            AVAssetWriterInput *micInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio
+                                                                              outputSettings:audioSettings];
+            micInput.expectsMediaDataInRealTime = YES;
+            if ([g_audioWriter canAddInput:micInput]) {
+                [g_audioWriter addInput:micInput];
+                g_microphoneAudioInput = micInput;
+                NSLog(@"✅ Microphone audio input created (stream 0 - Electron default)");
+            } else {
+                NSLog(@"❌ Cannot add microphone audio input");
+            }
+
+            // Create system audio input (stream 1)
+            AVAssetWriterInput *systemInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio
+                                                                                  outputSettings:audioSettings];
+            systemInput.expectsMediaDataInRealTime = YES;
+            if ([g_audioWriter canAddInput:systemInput]) {
+                [g_audioWriter addInput:systemInput];
+                g_systemAudioInput = systemInput;
+                NSLog(@"✅ System audio input created (stream 1)");
+            } else {
+                NSLog(@"❌ Cannot add system audio input");
+            }
+
+            return YES;
+        }
+    }
+
+    NSUInteger channelCount = MAX((NSUInteger)1, (NSUInteger)asbd->mChannelsPerFrame);
     AudioChannelLayout layout = {0};
     size_t layoutSize = 0;
     if (channelCount == 1) {
@@ -529,7 +985,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 
     NSMutableDictionary *audioSettings = [@{
         AVFormatIDKey: @(kAudioFormatMPEG4AAC),
-        AVSampleRateKey: @(g_configuredSampleRate),
+        AVSampleRateKey: @(asbd->mSampleRate),
         AVNumberOfChannelsKey: @(channelCount),
         AVEncoderBitRateKey: @(192000)
     } mutableCopy];
@@ -537,22 +993,27 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     if (layoutSize > 0) {
         audioSettings[AVChannelLayoutKey] = [NSData dataWithBytes:&layout length:layoutSize];
     }
-    
-    g_audioInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio outputSettings:audioSettings];
-    g_audioInput.expectsMediaDataInRealTime = YES;
 
-    MRLog(@"🎙️ Audio input created: sampleRate=%ld, channels=%ld, bitrate=192k",
-          (long)g_configuredSampleRate, (long)channelCount);
+    AVAssetWriterInput *newInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio
+                                                                      outputSettings:audioSettings];
+    newInput.expectsMediaDataInRealTime = YES;
 
-    if (![g_audioWriter canAddInput:g_audioInput]) {
-        NSLog(@"❌ Audio writer cannot add input");
+    if (![g_audioWriter canAddInput:newInput]) {
+        NSLog(@"❌ Audio writer cannot add %@ input", isMicrophone ? @"microphone" : @"system");
         return NO;
     }
-    [g_audioWriter addInput:g_audioInput];
-    g_audioWriterStarted = NO;
-    g_audioStartTime = kCMTimeInvalid;
+    [g_audioWriter addInput:newInput];
+
+    if (isMicrophone) {
+        g_microphoneAudioInput = newInput;
+        MRLog(@"🎙️ Microphone audio input created: sampleRate=%.0f, channels=%ld",
+              asbd->mSampleRate, (long)channelCount);
+    } else {
+        g_systemAudioInput = newInput;
+        MRLog(@"🔈 System audio input created: sampleRate=%.0f, channels=%ld",
+              asbd->mSampleRate, (long)channelCount);
+    }
 
-    MRLog(@"✅ Audio writer prepared successfully (path: %@)", g_audioOutputPath);
     return YES;
 }
 
@@ -564,181 +1025,462 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 }
 
 + (BOOL)startRecordingWithConfiguration:(NSDictionary *)config delegate:(id)delegate error:(NSError **)error {
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        if (g_isRecording || g_isCleaningUp) {
-            MRLog(@"⚠️ Already recording or cleaning up (recording:%d cleaning:%d)", g_isRecording, g_isCleaningUp);
-            return NO;
-        }
+    if (!config) {
+        return NO;
+    }
 
-        // Reset any stale state
-        g_isCleaningUp = NO;
+    NSDictionary *configCopy = [config copy];
+    dispatch_queue_t controlQueue = ScreenCaptureControlQueue();
+    __block BOOL accepted = NO;
 
-        // DON'T set g_isRecording here - wait for stream to actually start
-        // This prevents the "recording=1 stream=null" issue
-    }
+    dispatch_sync(controlQueue, ^{
+        if (g_isRecording || g_isCleaningUp || g_isScheduling) {
+            MRLog(@"⚠️ ScreenCaptureKit busy (recording:%d cleaning:%d scheduling:%d)", g_isRecording, g_isCleaningUp, g_isScheduling);
+            accepted = NO;
+            return;
+        }
+        g_isCleaningUp = NO;
+        g_isScheduling = YES;
+        accepted = YES;
+    });
 
-    NSString *outputPath = config[@"outputPath"];
-    if (!outputPath || [outputPath length] == 0) {
-        NSLog(@"❌ Invalid output path provided");
+    if (!accepted) {
         return NO;
     }
-    g_outputPath = outputPath;
-    
-    // Extract configuration options
-    NSNumber *displayId = config[@"displayId"];
-    NSNumber *windowId = config[@"windowId"];
-    NSDictionary *captureRect = config[@"captureRect"];
-    NSNumber *captureCursor = config[@"captureCursor"];
-    NSNumber *includeMicrophone = config[@"includeMicrophone"];
-    NSNumber *includeSystemAudio = config[@"includeSystemAudio"];
-    NSString *microphoneDeviceId = config[@"microphoneDeviceId"];
-    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);
-    
-    // CRITICAL DEBUG: Log EXACT audio parameter values
-    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 FULLY ASYNCHRONOUSLY
-    // NO semaphores, NO blocking - pure async to prevent Electron crashes
-    // CRITICAL: Run on background queue to avoid blocking Electron's main thread
+    // CRITICAL FIX: Use dispatch_get_global_queue instead of main_queue
+    // because Node.js standalone doesn't run macOS main event loop (only Electron does)
+    NSLog(@"🚀 Requesting shareable content...");
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
         [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
-            @autoreleasepool {
-            if (contentError) {
+            if (contentError || !content) {
                 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
-            }
-        
-        MRLog(@"✅ Got %lu displays, %lu windows for pure recording", 
-              content.displays.count, content.windows.count);
-        
-        // CRITICAL DEBUG: List all available displays in ScreenCaptureKit
-        MRLog(@"🔍 ScreenCaptureKit available displays:");
-        for (SCDisplay *display in content.displays) {
-            MRLog(@"   Display ID=%u, Size=%dx%d, Frame=(%.0f,%.0f,%.0fx%.0f)", 
-                  display.displayID, (int)display.width, (int)display.height,
-                  display.frame.origin.x, display.frame.origin.y,
-                  display.frame.size.width, display.frame.size.height);
-        }
-        
-        SCContentFilter *filter = nil;
-        NSInteger recordingWidth = 0;
-        NSInteger recordingHeight = 0;
-        SCDisplay *targetDisplay = nil;  // Move to shared scope
-        
-        // WINDOW RECORDING
-        if (windowId && [windowId integerValue] != 0) {
-            SCRunningApplication *targetApp = nil;
-            SCWindow *targetWindow = nil;
-            
-            for (SCWindow *window in content.windows) {
-                if (window.windowID == [windowId unsignedIntValue]) {
-                    targetWindow = window;
-                    targetApp = window.owningApplication;
-                    break;
-                }
+                SCKFailScheduling();
+                return;
             }
-            
-            if (targetWindow && targetApp) {
-                MRLog(@"🪟 Recording window: %@ (%ux%u)", 
-                      targetWindow.title, (unsigned)targetWindow.frame.size.width, (unsigned)targetWindow.frame.size.height);
-                filter = [[SCContentFilter alloc] initWithDesktopIndependentWindow:targetWindow];
-                recordingWidth = (NSInteger)targetWindow.frame.size.width;
-                recordingHeight = (NSInteger)targetWindow.frame.size.height;
+            NSLog(@"✅ Got shareable content, starting recording setup...");
+            dispatch_async(controlQueue, ^{
+                SCKPerformRecordingSetup(configCopy, content);
+            });
+        }];
+    });
+
+    return YES;
+}
+
++ (void)stopRecording {
+    if (!g_isRecording || !g_stream || g_isCleaningUp) {
+        NSLog(@"⚠️ Cannot stop: recording=%d stream=%@ cleaning=%d", g_isRecording, g_stream, g_isCleaningUp);
+        SCKMarkSchedulingComplete();
+        return;
+    }
+
+    MRLog(@"🛑 Stopping pure ScreenCaptureKit recording");
+
+    // CRITICAL FIX: Set cleanup flag IMMEDIATELY to prevent race conditions
+    // This prevents startRecording from being called while stop is in progress
+    @synchronized([ScreenCaptureKitRecorder class]) {
+        g_isCleaningUp = YES;
+    }
+
+    // Store stream reference to prevent it from being deallocated
+    SCStream *streamToStop = g_stream;
+
+    // ELECTRON FIX: Stop FULLY ASYNCHRONOUSLY - NO blocking, NO semaphores
+    [streamToStop stopCaptureWithCompletionHandler:^(NSError *stopError) {
+        @autoreleasepool {
+            if (stopError) {
+                NSLog(@"❌ Stop error: %@", stopError);
             } else {
-                NSLog(@"❌ Window ID %@ not found", windowId);
-                // No need to set g_isRecording=NO since it was never set to YES
-                return;  // Early return from completion handler block
+                MRLog(@"✅ Pure stream stopped");
             }
-        }
-        // DISPLAY RECORDING
-        else {
-            
-            if (displayId && [displayId integerValue] != 0) {
-                // Find specific display
-                MRLog(@"🎯 Looking for display ID=%@ in ScreenCaptureKit list", displayId);
-                for (SCDisplay *display in content.displays) {
-                    MRLog(@"   Checking display ID=%u vs requested=%u", display.displayID, [displayId unsignedIntValue]);
-                    if (display.displayID == [displayId unsignedIntValue]) {
-                        targetDisplay = display;
-                        MRLog(@"✅ FOUND matching display ID=%u", display.displayID);
-                        break;
+
+            // Reset recording state to allow new recordings
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+                g_isCleaningUp = NO; // CRITICAL: Reset cleanup flag when done
+            }
+
+            // Cleanup after stop completes
+            CleanupWriters();
+            [ScreenCaptureKitRecorder cleanupVideoWriter];
+
+            // Post-process: mix (if enabled) then mux audio into video file
+            if (g_shouldCaptureAudio && g_audioOutputPath) {
+                NSString *primaryAudioPath = ScreenCaptureKitCurrentAudioPath();
+                if ([primaryAudioPath isKindOfClass:[NSArray class]]) {
+                    id first = [(NSArray *)primaryAudioPath firstObject];
+                    if ([first isKindOfClass:[NSString class]]) {
+                        primaryAudioPath = (NSString *)first;
+                    } else {
+                        primaryAudioPath = nil;
                     }
                 }
-                
-                if (!targetDisplay) {
-                    NSLog(@"❌ Display ID=%@ NOT FOUND in ScreenCaptureKit - using first display as fallback", displayId);
-                    targetDisplay = content.displays.firstObject;
+                if (primaryAudioPath && [primaryAudioPath length] > 0) {
+                    BOOL preferInternal = NO;
+                    if (@available(macOS 15.0, *)) {
+                        preferInternal = (g_captureSystemAudioEnabled && g_captureMicrophoneEnabled);
+                    }
+                    NSString *externalMicPath = nil;
+                    if (currentStandaloneAudioRecordingPath) {
+                        externalMicPath = currentStandaloneAudioRecordingPath();
+                    }
+                    if (!externalMicPath || [externalMicPath length] == 0) {
+                        if (lastStandaloneAudioRecordingPath) {
+                            externalMicPath = lastStandaloneAudioRecordingPath();
+                        }
+                    }
+                    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
+                        NSString *audioForMux = primaryAudioPath;
+                        if (g_mixAudioEnabled) {
+                            BOOL mixed = NO;
+                            // Try gain-aware mix first
+                            mixed = MRMixAudioToSingleTrackWithGains(primaryAudioPath, externalMicPath, preferInternal, g_mixMicGain, g_mixSystemGain);
+                            if (!mixed) {
+                                mixed = MRMixAudioToSingleTrack(primaryAudioPath, externalMicPath, preferInternal);
+                            }
+                            if (mixed) {
+                                MRLog(@"🎧 Post-mix completed: %@", primaryAudioPath);
+                            } else {
+                                MRLog(@"ℹ️ Post-mix skipped or failed; proceeding to mux");
+                            }
+                        }
+                        if (g_outputPath && [g_outputPath length] > 0) {
+                            BOOL muxed = MRMuxAudioIntoVideo(g_outputPath, audioForMux);
+                            if (muxed) {
+                                MRLog(@"🔗 Muxed audio into video: %@", g_outputPath);
+                            } else {
+                                MRLog(@"⚠️ Failed to mux audio into video %@", g_outputPath);
+                            }
+                        }
+                    });
                 }
-            } else {
-                // Use first display
-                targetDisplay = content.displays.firstObject;
             }
-            
-            if (!targetDisplay) {
-                NSLog(@"❌ Display not found");
-                // No need to set g_isRecording=NO since it was never set to YES
-                return;  // Early return from completion handler block
-            }
-            
-            MRLog(@"🖥️ Recording display %u (%dx%d)", 
-                  targetDisplay.displayID, (int)targetDisplay.width, (int)targetDisplay.height);
-            filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:@[]];
-            recordingWidth = targetDisplay.width;
-            recordingHeight = targetDisplay.height;
+
+            SCKMarkSchedulingComplete();
         }
-        
-        // CROP AREA SUPPORT - Adjust dimensions and source rect
-        if (captureRect && captureRect[@"width"] && captureRect[@"height"]) {
-            CGFloat cropWidth = [captureRect[@"width"] doubleValue];
-            CGFloat cropHeight = [captureRect[@"height"] doubleValue];
-            
+    }];
+}
+
++ (BOOL)isRecording {
+    return g_isRecording;
+}
+
++ (BOOL)isFullyInitialized {
+    return g_firstFrameReceived;
+}
+
++ (NSTimeInterval)getVideoStartTimestamp {
+    if (!CMTIME_IS_VALID(g_videoStartTime)) {
+        return 0;
+    }
+    // Return as milliseconds since epoch - approximate using current time
+    // and relative offset from video start
+    NSDate *now = [NSDate date];
+    NSTimeInterval currentTimestamp = [now timeIntervalSince1970] * 1000;
+
+    // Calculate time elapsed since video start
+    CMTime currentCMTime = CMClockGetTime(CMClockGetHostTimeClock());
+    CMTime elapsedCMTime = CMTimeSubtract(currentCMTime, g_videoStartTime);
+    NSTimeInterval elapsedSeconds = CMTimeGetSeconds(elapsedCMTime);
+
+    // Video start timestamp = current timestamp - elapsed time
+    NSTimeInterval videoStartTimestamp = currentTimestamp - (elapsedSeconds * 1000);
+    return videoStartTimestamp;
+}
+
++ (BOOL)isCleaningUp {
+    return g_isCleaningUp;
+}
+
+@end
+
+// Export C function for checking cleanup state
+BOOL isScreenCaptureKitCleaningUp() API_AVAILABLE(macos(12.3)) {
+    return [ScreenCaptureKitRecorder isCleaningUp];
+}
+
+@implementation ScreenCaptureKitRecorder (Methods)
+
++ (BOOL)setupVideoWriter {
+    // No setup needed - SCRecordingOutput handles everything
+    return YES;
+}
+
++ (void)finalizeRecording {
+    @synchronized([ScreenCaptureKitRecorder class]) {
+        MRLog(@"🎬 Finalizing pure ScreenCaptureKit recording");
+        
+        // Set cleanup flag now that we're actually cleaning up
+        g_isCleaningUp = YES;
+        g_isRecording = NO;
+        
+        [ScreenCaptureKitRecorder cleanupVideoWriter];
+    }
+}
+
++ (void)finalizeVideoWriter {
+    // Alias for finalizeRecording to maintain compatibility
+    [ScreenCaptureKitRecorder finalizeRecording];
+}
+
++ (void)cleanupVideoWriter {
+    @synchronized([ScreenCaptureKitRecorder class]) {
+        MRLog(@"🧹 Starting ScreenCaptureKit cleanup");
+        
+        // Clean up in proper order to prevent crashes
+        if (g_stream) {
+            g_stream = nil;
+            MRLog(@"✅ Stream reference cleared");
+        }
+        
+        if (g_streamDelegate) {
+            g_streamDelegate = nil;
+            MRLog(@"✅ Stream delegate reference cleared");
+        }
+        
+        g_videoStreamOutput = nil;
+        g_audioStreamOutput = nil;
+        g_videoQueue = nil;
+        g_audioQueue = nil;
+        if (g_pixelBufferAdaptorRef) {
+            CFRelease(g_pixelBufferAdaptorRef);
+            g_pixelBufferAdaptorRef = NULL;
+        }
+        g_audioOutputPath = nil;
+        g_shouldCaptureAudio = NO;
+        g_captureMicrophoneEnabled = NO;
+        g_captureSystemAudioEnabled = NO;
+
+        g_isRecording = NO;
+        g_isCleaningUp = NO;  // Reset cleanup flag
+        g_outputPath = nil;
+
+        // ELECTRON FIX: Reset frame tracking
+        g_firstFrameReceived = NO;
+        g_frameCountSinceStart = 0;
+        
+        MRLog(@"🧹 Pure ScreenCaptureKit cleanup complete");
+    }
+}
+
+@end
+static dispatch_queue_t ScreenCaptureControlQueue(void) {
+    static dispatch_queue_t controlQueue = NULL;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        controlQueue = dispatch_queue_create("com.macrecorder.screencapture.control", DISPATCH_QUEUE_SERIAL);
+    });
+    return controlQueue;
+}
+
+static void SCKMarkSchedulingComplete(void) {
+    g_isScheduling = NO;
+}
+
+static void SCKFailScheduling(void) {
+    g_isScheduling = NO;
+    g_isRecording = NO;
+}
+
+static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *content) API_AVAILABLE(macos(12.3)) {
+    @autoreleasepool {
+        if (!config || !content) {
+            SCKFailScheduling();
+            return;
+        }
+
+        // CRITICAL FIX: Reset frame tracking at START of new recording
+        g_firstFrameReceived = NO;
+        g_frameCountSinceStart = 0;
+        NSLog(@"🔄 Frame tracking reset for new recording");
+
+        NSString *outputPath = config[@"outputPath"];
+        if (!outputPath || [outputPath length] == 0) {
+            NSLog(@"❌ Invalid output path provided");
+            SCKFailScheduling();
+            return;
+        }
+        g_outputPath = outputPath;
+
+        NSNumber *displayId = config[@"displayId"];
+        NSNumber *windowId = config[@"windowId"];
+        NSDictionary *captureRect = config[@"captureRect"];
+        NSNumber *captureCursor = config[@"captureCursor"];
+        NSNumber *includeMicrophone = config[@"includeMicrophone"];
+        NSNumber *includeSystemAudio = config[@"includeSystemAudio"];
+        NSString *microphoneDeviceId = config[@"microphoneDeviceId"];
+        NSString *audioOutputPath = MRNormalizePath(config[@"audioOutputPath"]);
+        NSNumber *sessionTimestampNumber = config[@"sessionTimestamp"];
+        NSNumber *frameRateNumber = config[@"frameRate"];
+        NSNumber *mixAudioNumber = config[@"mixAudio"];
+        g_mixAudioEnabled = mixAudioNumber ? [mixAudioNumber boolValue] : YES;
+        NSNumber *mixMicGainNumber = config[@"mixMicGain"];
+        NSNumber *mixSystemGainNumber = config[@"mixSystemGain"];
+        if (mixMicGainNumber && [mixMicGainNumber respondsToSelector:@selector(floatValue)]) {
+            g_mixMicGain = [mixMicGainNumber floatValue];
+            if (g_mixMicGain < 0.f) g_mixMicGain = 0.f;
+            if (g_mixMicGain > 2.f) g_mixMicGain = 2.f;
+        }
+        if (mixSystemGainNumber && [mixSystemGainNumber respondsToSelector:@selector(floatValue)]) {
+            g_mixSystemGain = [mixSystemGainNumber floatValue];
+            if (g_mixSystemGain < 0.f) g_mixSystemGain = 0.f;
+            if (g_mixSystemGain > 2.f) g_mixSystemGain = 2.f;
+        }
+        g_qualityPreset = SCKNormalizeQualityPreset(config[@"quality"]);
+        MRLog(@"🎚️ Requested quality preset: %@", g_qualityPreset);
+        NSNumber *captureCamera = config[@"captureCamera"];
+
+        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;
+        }
+
+        // CRITICAL ELECTRON FIX: Lower FPS to 30 when recording with camera
+        // This prevents resource conflicts and crashes when running both simultaneously
+        BOOL isCameraEnabled = captureCamera && [captureCamera boolValue];
+        if (isCameraEnabled && g_targetFPS > 30) {
+            MRLog(@"📹 Camera recording detected - lowering ScreenCaptureKit FPS from %ld to 30 for stability", (long)g_targetFPS);
+            g_targetFPS = 30;
+        }
+
+        MRLog(@"🎬 Starting PURE ScreenCaptureKit recording (NO AVFoundation)");
+        MRLog(@"🔧 Config: cursor=%@ mic=%@ system=%@ display=%@ window=%@ crop=%@",
+              captureCursor, includeMicrophone, includeSystemAudio, displayId, windowId, captureRect);
+        MRLog(@"🔍 AUDIO DEBUG: includeMicrophone type=%@ value=%d", [includeMicrophone class], [includeMicrophone boolValue]);
+        MRLog(@"🔍 AUDIO DEBUG: includeSystemAudio type=%@ value=%d", [includeSystemAudio class], [includeSystemAudio boolValue]);
+        MRLog(@"🎚️ Post-mix enabled: %@ (mic=%.2f, sys=%.2f)", g_mixAudioEnabled ? @"YES" : @"NO", g_mixMicGain, g_mixSystemGain);
+
+        MRLog(@"✅ Got %lu displays, %lu windows for pure recording",
+              content.displays.count, content.windows.count);
+        MRLog(@"🔍 ScreenCaptureKit available displays:");
+        for (SCDisplay *display in content.displays) {
+            MRLog(@"   Display ID=%u, Size=%dx%d, Frame=(%.0f,%.0f,%.0fx%.0f)",
+                  display.displayID, (int)display.width, (int)display.height,
+                  display.frame.origin.x, display.frame.origin.y,
+                  display.frame.size.width, display.frame.size.height);
+        }
+
+        SCContentFilter *filter = nil;
+        NSInteger recordingWidth = 0;
+        NSInteger recordingHeight = 0;
+        SCDisplay *targetDisplay = nil;
+
+        if (windowId && [windowId integerValue] != 0) {
+            SCRunningApplication *targetApp = nil;
+            SCWindow *targetWindow = nil;
+
+            for (SCWindow *window in content.windows) {
+                if (window.windowID == [windowId unsignedIntValue]) {
+                    targetWindow = window;
+                    targetApp = window.owningApplication;
+                    break;
+                }
+            }
+
+            if (targetWindow && targetApp) {
+                MRLog(@"🪟 Recording window: %@ (%ux%u)",
+                      targetWindow.title, (unsigned)targetWindow.frame.size.width, (unsigned)targetWindow.frame.size.height);
+                filter = [[SCContentFilter alloc] initWithDesktopIndependentWindow:targetWindow];
+                recordingWidth = (NSInteger)targetWindow.frame.size.width;
+                recordingHeight = (NSInteger)targetWindow.frame.size.height;
+            } else {
+                NSLog(@"❌ Window ID %@ not found", windowId);
+                SCKFailScheduling();
+                return;
+            }
+        } else {
+            if (displayId) {
+                for (SCDisplay *display in content.displays) {
+                    if (display.displayID == [displayId unsignedIntValue]) {
+                        targetDisplay = display;
+                        break;
+                    }
+                }
+
+                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) {
+                targetDisplay = content.displays.firstObject;
+            }
+
+            if (targetDisplay) {
+                MRLog(@"🖥️ Recording display %u (%dx%d)",
+                      targetDisplay.displayID, (int)targetDisplay.width, (int)targetDisplay.height);
+                filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:@[]];
+                recordingWidth = targetDisplay.width;
+                recordingHeight = targetDisplay.height;
+            } else {
+                NSLog(@"❌ No display available");
+                SCKFailScheduling();
+                return;
+            }
+        }
+
+        if (captureRect && captureRect[@"width"] && captureRect[@"height"]) {
+            CGFloat cropWidth = [captureRect[@"width"] doubleValue];
+            CGFloat cropHeight = [captureRect[@"height"] doubleValue];
             if (cropWidth > 0 && cropHeight > 0) {
-                MRLog(@"🔲 Crop area specified: %.0fx%.0f at (%.0f,%.0f)", 
-                      cropWidth, cropHeight, 
+                MRLog(@"🔲 Crop area specified: %.0fx%.0f at (%.0f,%.0f)",
+                      cropWidth, cropHeight,
                       [captureRect[@"x"] doubleValue], [captureRect[@"y"] doubleValue]);
                 recordingWidth = (NSInteger)cropWidth;
                 recordingHeight = (NSInteger)cropHeight;
             }
         }
-        
-        // Configure stream with HIGH QUALITY settings
+
+        CGFloat qualityScale = SCKQualityScaleForPreset(g_qualityPreset);
+        if (qualityScale < 0.999 && recordingWidth > 0 && recordingHeight > 0) {
+            NSInteger scaledWidth = MAX(1, (NSInteger)((double)recordingWidth * qualityScale + 0.5));
+            NSInteger scaledHeight = MAX(1, (NSInteger)((double)recordingHeight * qualityScale + 0.5));
+            MRLog(@"🎚️ Quality '%@': scaling output to %ldx%ld (%.0f%% of source %ldx%ld)",
+                  g_qualityPreset,
+                  (long)scaledWidth,
+                  (long)scaledHeight,
+                  qualityScale * 100.0,
+                  (long)recordingWidth,
+                  (long)recordingHeight);
+            recordingWidth = scaledWidth;
+            recordingHeight = scaledHeight;
+        } else {
+            MRLog(@"🎚️ Quality '%@': using full resolution %ldx%ld",
+                  g_qualityPreset,
+                  (long)recordingWidth,
+                  (long)recordingHeight);
+        }
+
         SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
         streamConfig.width = recordingWidth;
         streamConfig.height = recordingHeight;
         streamConfig.minimumFrameInterval = CMTimeMake(1, (int)MAX(1, g_targetFPS));
         streamConfig.pixelFormat = kCVPixelFormatType_32BGRA;
         streamConfig.scalesToFit = NO;
-
-        // QUALITY FIX: Set high quality encoding parameters
         if (@available(macOS 13.0, *)) {
-            streamConfig.queueDepth = 8; // Larger queue for smoother capture
+            streamConfig.queueDepth = 8;
         }
 
-        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;
-        g_shouldCaptureAudio = shouldCaptureMic || shouldCaptureSystemAudio;
+        g_shouldCaptureAudio = shouldCaptureSystemAudio || shouldCaptureMic;
+        g_captureMicrophoneEnabled = shouldCaptureMic;
+        g_captureSystemAudioEnabled = shouldCaptureSystemAudio;
 
-        // SAFETY: Ensure audioOutputPath is NSString, not NSURL or other type
         if (audioOutputPath && ![audioOutputPath isKindOfClass:[NSString class]]) {
             MRLog(@"⚠️ audioOutputPath type mismatch: %@, converting...", NSStringFromClass([audioOutputPath class]));
             g_audioOutputPath = nil;
@@ -749,84 +1491,82 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         if (g_shouldCaptureAudio && (!g_audioOutputPath || [g_audioOutputPath length] == 0)) {
             NSLog(@"⚠️ Audio capture requested but no audio output path supplied – audio will be disabled");
             g_shouldCaptureAudio = NO;
+            g_captureMicrophoneEnabled = NO;
+            g_captureSystemAudioEnabled = NO;
         }
-        
+
         if (@available(macos 13.0, *)) {
-            // capturesAudio enables audio capture (both mic and system audio)
             streamConfig.capturesAudio = g_shouldCaptureAudio;
             streamConfig.sampleRate = g_configuredSampleRate ?: 48000;
             streamConfig.channelCount = g_configuredChannelCount ?: 2;
-
-            // excludesCurrentProcessAudio = YES means ONLY microphone
-            // excludesCurrentProcessAudio = NO means system audio + mic
             streamConfig.excludesCurrentProcessAudio = !shouldCaptureSystemAudio;
-
-            MRLog(@"🎤 Audio config (macOS 13+): capturesAudio=%d, excludeProcess=%d (mic=%d sys=%d)",
+            NSLog(@"🎤 Audio config (macOS 13+): capturesAudio=%d, excludeProcess=%d (mic=%d sys=%d)",
                   g_shouldCaptureAudio, streamConfig.excludesCurrentProcessAudio,
                   shouldCaptureMic, shouldCaptureSystemAudio);
         }
 
         if (@available(macos 15.0, *)) {
-            // macOS 15+ has explicit microphone control
             streamConfig.captureMicrophone = shouldCaptureMic;
-            if (microphoneDeviceId && microphoneDeviceId.length > 0) {
-                streamConfig.microphoneCaptureDeviceID = microphoneDeviceId;
+            NSString *micIdToUse = microphoneDeviceId;
+            if (micIdToUse && micIdToUse.length > 0) {
+                // Validate UniqueID; if invalid, fall back to default to avoid silencing mic
+                AVCaptureDevice *dev = [AVCaptureDevice deviceWithUniqueID:micIdToUse];
+                if (!dev) {
+                    NSLog(@"⚠️ Invalid microphone deviceID '%@' – falling back to default", micIdToUse);
+                    micIdToUse = nil;
+                }
             }
-            MRLog(@"🎤 Microphone (macOS 15+): enabled=%d, deviceID=%@",
-                  shouldCaptureMic, microphoneDeviceId ?: @"default");
+            if (micIdToUse && micIdToUse.length > 0) {
+                streamConfig.microphoneCaptureDeviceID = micIdToUse;
+            }
+            NSLog(@"🎤 Microphone (macOS 15+): enabled=%d, deviceID=%@",
+                  shouldCaptureMic, micIdToUse ?: @"default");
         }
-        
-        // Apply crop area using sourceRect - CONVERT GLOBAL TO DISPLAY-RELATIVE COORDINATES
-        if (captureRect && captureRect[@"x"] && captureRect[@"y"] && captureRect[@"width"] && captureRect[@"height"]) {
-            CGFloat globalX = [captureRect[@"x"] doubleValue];
-            CGFloat globalY = [captureRect[@"y"] doubleValue];
+
+        if (captureRect && captureRect[@"x"] && captureRect[@"y"] && captureRect[@"width"] && captureRect[@"height"] && targetDisplay) {
+            // CRITICAL FIX: captureRect comes from index.js as ALREADY display-relative coordinates
+            // (see index.js:371-376 where global coords are converted to display-relative)
+            // So we should NOT subtract display origin again - just use them directly!
+            CGFloat displayRelativeX = [captureRect[@"x"] doubleValue];
+            CGFloat displayRelativeY = [captureRect[@"y"] doubleValue];
             CGFloat cropWidth = [captureRect[@"width"] doubleValue];
             CGFloat cropHeight = [captureRect[@"height"] doubleValue];
-            
-            if (cropWidth > 0 && cropHeight > 0 && targetDisplay) {
-                // Convert global coordinates to display-relative coordinates
-                CGRect displayBounds = targetDisplay.frame;
-                CGFloat displayRelativeX = globalX - displayBounds.origin.x;
-                CGFloat displayRelativeY = globalY - displayBounds.origin.y;
-                
-                MRLog(@"🌐 Global coords: (%.0f,%.0f) on Display ID=%u", globalX, globalY, targetDisplay.displayID);
-                MRLog(@"🖥️ Display bounds: (%.0f,%.0f,%.0fx%.0f)", 
-                      displayBounds.origin.x, displayBounds.origin.y, 
+            CGRect displayBounds = targetDisplay.frame;
+
+            MRLog(@"🔍 CROP DEBUG: Input coords=(%.0f,%.0f) size=(%.0fx%.0f)",
+                  displayRelativeX, displayRelativeY, cropWidth, cropHeight);
+            MRLog(@"🔍 CROP DEBUG: Display bounds origin=(%.0f,%.0f) size=(%.0fx%.0f)",
+                  displayBounds.origin.x, displayBounds.origin.y,
+                  displayBounds.size.width, displayBounds.size.height);
+
+            if (displayRelativeX >= 0 && displayRelativeY >= 0 &&
+                displayRelativeX + cropWidth <= displayBounds.size.width &&
+                displayRelativeY + cropHeight <= displayBounds.size.height) {
+                CGRect sourceRect = CGRectMake(displayRelativeX, displayRelativeY, cropWidth, cropHeight);
+                streamConfig.sourceRect = sourceRect;
+                MRLog(@"✂️ Crop sourceRect applied: (%.0f,%.0f) %.0fx%.0f (display-relative)",
+                      displayRelativeX, displayRelativeY, cropWidth, cropHeight);
+            } else {
+                NSLog(@"❌ Crop coordinates out of display bounds - skipping crop");
+                MRLog(@"   Coords: (%.0f,%.0f) size:(%.0fx%.0f) vs display:(%.0fx%.0f)",
+                      displayRelativeX, displayRelativeY, cropWidth, cropHeight,
                       displayBounds.size.width, displayBounds.size.height);
-                MRLog(@"📍 Display-relative: (%.0f,%.0f) -> SourceRect", displayRelativeX, displayRelativeY);
-                
-                // Validate coordinates are within display bounds
-                if (displayRelativeX >= 0 && displayRelativeY >= 0 && 
-                    displayRelativeX + cropWidth <= displayBounds.size.width &&
-                    displayRelativeY + cropHeight <= displayBounds.size.height) {
-                    
-                    CGRect sourceRect = CGRectMake(displayRelativeX, displayRelativeY, cropWidth, cropHeight);
-                    streamConfig.sourceRect = sourceRect;
-                    MRLog(@"✂️ Crop sourceRect applied: (%.0f,%.0f) %.0fx%.0f (display-relative)", 
-                          displayRelativeX, displayRelativeY, cropWidth, cropHeight);
-                } else {
-                    NSLog(@"❌ Crop coordinates out of display bounds - skipping crop");
-                    MRLog(@"   Relative: (%.0f,%.0f) size:(%.0fx%.0f) vs display:(%.0fx%.0f)",
-                          displayRelativeX, displayRelativeY, cropWidth, cropHeight,
-                          displayBounds.size.width, displayBounds.size.height);
-                }
             }
         }
-        
-        // CURSOR SUPPORT
+
         BOOL shouldShowCursor = captureCursor ? [captureCursor boolValue] : YES;
         streamConfig.showsCursor = shouldShowCursor;
-        
-        MRLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ %ldfps, cursor=%d", 
+        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]) {
             NSLog(@"❌ Failed to prepare video writer: %@", writerError);
-            // No need to set g_isRecording=NO since it was never set to YES
-            return;  // Early return from completion handler block
+            SCKFailScheduling();
+            CleanupWriters();
+            return;
         }
-        
+
         g_videoQueue = dispatch_queue_create("screen_capture_video_queue", DISPATCH_QUEUE_SERIAL);
         g_audioQueue = dispatch_queue_create("screen_capture_audio_queue", DISPATCH_QUEUE_SERIAL);
         g_videoStreamOutput = [[ScreenCaptureVideoOutput alloc] init];
@@ -835,20 +1575,16 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         } else {
             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();
-            return;  // Early return from completion handler block
+            SCKFailScheduling();
+            return;
         }
 
-        MRLog(@"✅ Stream created successfully");
-
         NSError *outputError = nil;
         BOOL videoOutputAdded = [g_stream addStreamOutput:g_videoStreamOutput type:SCStreamOutputTypeScreen sampleHandlerQueue:g_videoQueue error:&outputError];
         if (!videoOutputAdded || outputError) {
@@ -857,24 +1593,81 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             @synchronized([ScreenCaptureKitRecorder class]) {
                 g_stream = nil;
             }
-            return;  // Early return from completion handler block
+            SCKFailScheduling();
+            return;
         }
 
         if (g_shouldCaptureAudio) {
             if (@available(macOS 13.0, *)) {
                 NSError *audioError = nil;
-                BOOL audioOutputAdded = [g_stream addStreamOutput:g_audioStreamOutput type:SCStreamOutputTypeAudio sampleHandlerQueue:g_audioQueue error:&audioError];
-                if (!audioOutputAdded || audioError) {
-                    NSLog(@"❌ Failed to add audio output: %@", audioError);
-                    CleanupWriters();
-                    @synchronized([ScreenCaptureKitRecorder class]) {
-                        g_stream = nil;
+                BOOL anyAudioAdded = NO;
+                if (@available(macOS 15.0, *)) {
+                    // On macOS 15+, microphone has its own output type
+                    if (g_captureMicrophoneEnabled) {
+                        NSLog(@"➕ Adding microphone output stream...");
+                        audioError = nil;
+                        BOOL micAdded = [g_stream addStreamOutput:g_audioStreamOutput
+                                                             type:SCStreamOutputTypeMicrophone
+                                               sampleHandlerQueue:g_audioQueue
+                                                            error:&audioError];
+                        if (!micAdded || audioError) {
+                            NSLog(@"❌ Failed to add microphone output: %@", audioError);
+                            CleanupWriters();
+                            @synchronized([ScreenCaptureKitRecorder class]) { g_stream = nil; }
+                            SCKFailScheduling();
+                            return;
+                        }
+                        anyAudioAdded = YES;
+                        NSLog(@"✅ Microphone output added successfully");
+                    }
+                    if (g_captureSystemAudioEnabled) {
+                        NSLog(@"➕ Adding system audio output stream...");
+                        audioError = nil;
+                        BOOL sysAdded = [g_stream addStreamOutput:g_audioStreamOutput
+                                                            type:SCStreamOutputTypeAudio
+                                              sampleHandlerQueue:g_audioQueue
+                                                           error:&audioError];
+                        if (!sysAdded || audioError) {
+                            NSLog(@"❌ Failed to add system audio output: %@", audioError);
+                            CleanupWriters();
+                            @synchronized([ScreenCaptureKitRecorder class]) { g_stream = nil; }
+                            SCKFailScheduling();
+                            return;
+                        }
+                        anyAudioAdded = YES;
+                        NSLog(@"✅ System audio output added successfully");
                     }
-                    return;  // Early return from completion handler block
+                } else {
+                    // macOS 13/14: only SCStreamOutputTypeAudio exists
+                    NSLog(@"➕ Adding audio output stream (macOS 13/14)...");
+                    audioError = nil;
+                    BOOL audAdded = [g_stream addStreamOutput:g_audioStreamOutput
+                                                        type:SCStreamOutputTypeAudio
+                                          sampleHandlerQueue:g_audioQueue
+                                                       error:&audioError];
+                    if (!audAdded || audioError) {
+                        NSLog(@"❌ Failed to add audio output: %@", audioError);
+                        CleanupWriters();
+                        @synchronized([ScreenCaptureKitRecorder class]) { g_stream = nil; }
+                        SCKFailScheduling();
+                        return;
+                    }
+                    anyAudioAdded = YES;
+                    NSLog(@"✅ Audio output added successfully");
+                }
+
+                if (!anyAudioAdded) {
+                    NSLog(@"❌ No audio outputs added (unexpected configuration)");
+                    CleanupWriters();
+                    @synchronized([ScreenCaptureKitRecorder class]) { g_stream = nil; }
+                    SCKFailScheduling();
+                    return;
                 }
             } else {
                 NSLog(@"⚠️ Audio capture requested but requires macOS 13.0+");
                 g_shouldCaptureAudio = NO;
+                g_captureMicrophoneEnabled = NO;
+                g_captureSystemAudioEnabled = NO;
             }
         }
 
@@ -883,141 +1676,28 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             MRLog(@"🕒 Session timestamp: %@", sessionTimestampNumber);
         }
 
-        // Start capture - can be async
+        NSLog(@"🚀 CALLING startCaptureWithCompletionHandler (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!");
-                // NOW set recording flag - stream is actually running
-                @synchronized([ScreenCaptureKitRecorder class]) {
-                    g_isRecording = YES;
+            dispatch_async(ScreenCaptureControlQueue(), ^{
+                if (startError) {
+                    NSLog(@"❌ Failed to start pure capture: %@", startError);
+                    NSLog(@"❌ Error domain: %@, code: %ld", startError.domain, (long)startError.code);
+                    NSLog(@"❌ Error userInfo: %@", startError.userInfo);
+                    CleanupWriters();
+                    @synchronized([ScreenCaptureKitRecorder class]) {
+                        g_isRecording = NO;
+                        g_stream = nil;
+                    }
+                    SCKFailScheduling();
+                } else {
+                    NSLog(@"🎉 PURE ScreenCaptureKit recording started successfully!");
+                    NSLog(@"🎤 Audio capture enabled: %d (mic=%d, system=%d)", g_shouldCaptureAudio, g_captureMicrophoneEnabled, g_captureSystemAudioEnabled);
+                    @synchronized([ScreenCaptureKitRecorder class]) {
+                        g_isRecording = YES;
+                    }
+                    SCKMarkSchedulingComplete();
                 }
-            }
-        }];  // End of startCaptureWithCompletionHandler
-        }  // End of autoreleasepool
-        }];  // End of getShareableContentWithCompletionHandler
-    });  // End of dispatch_async
-
-    // Return immediately - async completion will handle success/failure
-    return YES;
-}
-
-+ (void)stopRecording {
-    if (!g_isRecording || !g_stream || g_isCleaningUp) {
-        NSLog(@"⚠️ Cannot stop: recording=%d stream=%@ cleaning=%d", g_isRecording, g_stream, g_isCleaningUp);
-        return;
-    }
-
-    MRLog(@"🛑 Stopping pure ScreenCaptureKit recording");
-
-    // CRITICAL FIX: Set cleanup flag IMMEDIATELY to prevent race conditions
-    // This prevents startRecording from being called while stop is in progress
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        g_isCleaningUp = YES;
-    }
-
-    // Store stream reference to prevent it from being deallocated
-    SCStream *streamToStop = g_stream;
-
-    // ELECTRON FIX: Stop FULLY ASYNCHRONOUSLY - NO blocking, NO semaphores
-    [streamToStop stopCaptureWithCompletionHandler:^(NSError *stopError) {
-        @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;
-                g_isCleaningUp = NO; // CRITICAL: Reset cleanup flag when done
-            }
-
-            // Cleanup after stop completes
-            CleanupWriters();
-            [ScreenCaptureKitRecorder cleanupVideoWriter];
-        }
-    }];
-}
-
-+ (BOOL)isRecording {
-    return g_isRecording;
-}
-
-+ (BOOL)isCleaningUp {
-    return g_isCleaningUp;
-}
-
-@end
-
-// Export C function for checking cleanup state
-BOOL isScreenCaptureKitCleaningUp() API_AVAILABLE(macos(12.3)) {
-    return [ScreenCaptureKitRecorder isCleaningUp];
-}
-
-@implementation ScreenCaptureKitRecorder (Methods)
-
-+ (BOOL)setupVideoWriter {
-    // No setup needed - SCRecordingOutput handles everything
-    return YES;
-}
-
-+ (void)finalizeRecording {
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        MRLog(@"🎬 Finalizing pure ScreenCaptureKit recording");
-        
-        // Set cleanup flag now that we're actually cleaning up
-        g_isCleaningUp = YES;
-        g_isRecording = NO;
-        
-        [ScreenCaptureKitRecorder cleanupVideoWriter];
+            });
+        }];
     }
 }
-
-+ (void)finalizeVideoWriter {
-    // Alias for finalizeRecording to maintain compatibility
-    [ScreenCaptureKitRecorder finalizeRecording];
-}
-
-+ (void)cleanupVideoWriter {
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        MRLog(@"🧹 Starting ScreenCaptureKit cleanup");
-        
-        // Clean up in proper order to prevent crashes
-        if (g_stream) {
-            g_stream = nil;
-            MRLog(@"✅ Stream reference cleared");
-        }
-        
-        if (g_streamDelegate) {
-            g_streamDelegate = nil;
-            MRLog(@"✅ Stream delegate reference cleared");
-        }
-        
-        g_videoStreamOutput = nil;
-        g_audioStreamOutput = nil;
-        g_videoQueue = nil;
-        g_audioQueue = nil;
-        if (g_pixelBufferAdaptorRef) {
-            CFRelease(g_pixelBufferAdaptorRef);
-            g_pixelBufferAdaptorRef = NULL;
-        }
-        g_audioOutputPath = nil;
-        g_shouldCaptureAudio = NO;
-        
-        g_isRecording = NO;
-        g_isCleaningUp = NO;  // Reset cleanup flag
-        g_outputPath = nil;
-        
-        MRLog(@"🧹 Pure ScreenCaptureKit cleanup complete");
-    }
-}
-
-@end