node-mac-recorder 2.21.0 → 2.21.1

package/MACOS_PERMISSIONS.md

@@ -24,6 +24,8 @@ This project relies on system-level frameworks (ScreenCaptureKit, AVFoundation)
 > `NSCameraUseContinuityCameraDeviceType` removes the runtime warning when Continuity Camera devices are detected. macOS 14+ expects this key whenever Continuity Camera APIs are used.
 > The `com.apple.security.*` entitlements are only required for sandboxed / hardened runtime builds. Omit them if your distribution does not use the macOS sandbox.
 
+During local development you can temporarily bypass the Continuity Camera check by running with `ALLOW_CONTINUITY_CAMERA=1`, but Apple still recommends setting the Info.plist key for shipping applications.
+
 ### Screen recording
 
 Screen recording permissions are granted by the user via the OS **Screen Recording** privacy panel. There is no `Info.plist` key to request it, but your app should guide the user to approve it.

package/index.js

@@ -425,12 +425,12 @@ class MacRecorder extends EventEmitter {
 				this.sessionTimestamp = sessionTimestamp;
 				const outputDir = path.dirname(outputPath);
 				const cursorFilePath = path.join(outputDir, `temp_cursor_${sessionTimestamp}.json`);
-				const cameraFilePath =
+				let cameraFilePath =
 					this.options.captureCamera === true
 						? path.join(outputDir, `temp_camera_${sessionTimestamp}.webm`)
 						: null;
 				const captureAudio = this.options.includeMicrophone === true || this.options.includeSystemAudio === true;
-				const audioFilePath = captureAudio
+				let audioFilePath = captureAudio
 					? path.join(outputDir, `temp_audio_${sessionTimestamp}.webm`)
 					: null;
 
@@ -451,11 +451,11 @@ class MacRecorder extends EventEmitter {
 				}
 
 				// Native kayıt başlat
-				const recordingOptions = {
-					includeMicrophone: this.options.includeMicrophone === true, // Only if explicitly enabled
-					includeSystemAudio: this.options.includeSystemAudio === true, // Only if explicitly enabled
-					captureCursor: this.options.captureCursor || false,
-					displayId: this.options.displayId || null, // null = ana ekran
+					let recordingOptions = {
+						includeMicrophone: this.options.includeMicrophone === true, // Only if explicitly enabled
+						includeSystemAudio: this.options.includeSystemAudio === true, // Only if explicitly enabled
+						captureCursor: this.options.captureCursor || false,
+						displayId: this.options.displayId || null, // null = ana ekran
 					windowId: this.options.windowId || null, // null = tam ekran
 					audioDeviceId: this.options.audioDeviceId || null, // null = default device
 					systemAudioDeviceId: this.options.systemAudioDeviceId || null, // null = auto-detect system audio device
@@ -464,12 +464,18 @@ class MacRecorder extends EventEmitter {
 					sessionTimestamp,
 				};
 
-				if (cameraFilePath) {
-					recordingOptions.cameraOutputPath = cameraFilePath;
-				}
+					if (cameraFilePath) {
+						recordingOptions = {
+							...recordingOptions,
+							cameraOutputPath: cameraFilePath,
+						};
+					}
 
-				if (audioFilePath) {
-					recordingOptions.audioOutputPath = audioFilePath;
+					if (audioFilePath) {
+						recordingOptions = {
+							...recordingOptions,
+							audioOutputPath: audioFilePath,
+						};
 				}
 
 				// Manuel captureArea varsa onu kullan
@@ -494,6 +500,32 @@ class MacRecorder extends EventEmitter {
 				}
 
 				if (success) {
+					if (this.options.captureCamera === true) {
+						try {
+							const nativeCameraPath = nativeBinding.getCameraRecordingPath
+								? nativeBinding.getCameraRecordingPath()
+								: null;
+							if (typeof nativeCameraPath === "string" && nativeCameraPath.length > 0) {
+								this.cameraCaptureFile = nativeCameraPath;
+								cameraFilePath = nativeCameraPath;
+							}
+						} catch (pathError) {
+							console.warn("Camera output path sync failed:", pathError.message);
+						}
+					}
+					if (captureAudio) {
+						try {
+							const nativeAudioPath = nativeBinding.getAudioRecordingPath
+								? nativeBinding.getAudioRecordingPath()
+								: null;
+							if (typeof nativeAudioPath === "string" && nativeAudioPath.length > 0) {
+								this.audioCaptureFile = nativeAudioPath;
+								audioFilePath = nativeAudioPath;
+							}
+						} catch (pathError) {
+							console.warn("Audio output path sync failed:", pathError.message);
+						}
+					}
 					this.isRecording = true;
 					this.recordingStartTime = Date.now();
 
@@ -664,6 +696,33 @@ class MacRecorder extends EventEmitter {
 					success = true; // Assume success to avoid throwing
 				}
 
+				if (this.options.captureCamera === true) {
+					try {
+						const nativeCameraPath = nativeBinding.getCameraRecordingPath
+							? nativeBinding.getCameraRecordingPath()
+							: null;
+						if (typeof nativeCameraPath === "string" && nativeCameraPath.length > 0) {
+							this.cameraCaptureFile = nativeCameraPath;
+						}
+					} catch (pathError) {
+						console.warn("Camera output path sync failed:", pathError.message);
+					}
+				}
+
+				const captureAudio = this.options.includeMicrophone === true || this.options.includeSystemAudio === true;
+				if (captureAudio) {
+					try {
+						const nativeAudioPath = nativeBinding.getAudioRecordingPath
+							? nativeBinding.getAudioRecordingPath()
+							: null;
+						if (typeof nativeAudioPath === "string" && nativeAudioPath.length > 0) {
+							this.audioCaptureFile = nativeAudioPath;
+						}
+					} catch (pathError) {
+						console.warn("Audio output path sync failed:", pathError.message);
+					}
+				}
+
 				if (this.cameraCaptureActive) {
 					this.cameraCaptureActive = false;
 					this.emit("cameraCaptureStopped", {

package/package.json

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

package/src/audio_recorder.mm

@@ -55,13 +55,49 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
     NSURL *outputURL = [NSURL fileURLWithPath:self.outputPath];
     [[NSFileManager defaultManager] removeItemAtURL:outputURL error:nil];
     
-    AVFileType fileType = AVFileTypeQuickTimeMovie;
+    NSError *writerError = nil;
+    AVFileType requestedFileType = AVFileTypeQuickTimeMovie;
+    BOOL requestedWebM = NO;
     if (@available(macOS 15.0, *)) {
-        fileType = @"public.webm";
+        requestedFileType = @"public.webm";
+        requestedWebM = YES;
+    }
+    
+    @try {
+        self.writer = [[AVAssetWriter alloc] initWithURL:outputURL fileType:requestedFileType error:&writerError];
+    } @catch (NSException *exception) {
+        NSDictionary *info = @{
+            NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize audio writer"
+        };
+        writerError = [NSError errorWithDomain:@"NativeAudioRecorder" code:-30 userInfo:info];
+        self.writer = nil;
     }
     
-    self.writer = [[AVAssetWriter alloc] initWithURL:outputURL fileType:fileType error:error];
-    if (!self.writer || (*error)) {
+    if ((!self.writer || writerError) && requestedWebM) {
+        NSString *fallbackPath = [[self.outputPath stringByDeletingPathExtension] stringByAppendingPathExtension:@"mov"];
+        if (!fallbackPath || [fallbackPath length] == 0) {
+            fallbackPath = [self.outputPath stringByAppendingString:@".mov"];
+        }
+        [[NSFileManager defaultManager] removeItemAtPath:fallbackPath error:nil];
+        NSURL *fallbackURL = [NSURL fileURLWithPath:fallbackPath];
+        self.outputPath = fallbackPath;
+        writerError = nil;
+        @try {
+            self.writer = [[AVAssetWriter alloc] initWithURL:fallbackURL fileType:AVFileTypeQuickTimeMovie error:&writerError];
+        } @catch (NSException *exception) {
+            NSDictionary *info = @{
+                NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize audio writer"
+            };
+            writerError = [NSError errorWithDomain:@"NativeAudioRecorder" code:-31 userInfo:info];
+            self.writer = nil;
+        }
+        outputURL = fallbackURL;
+    }
+    
+    if (!self.writer || writerError) {
+        if (error) {
+            *error = writerError;
+        }
         return NO;
     }
     
@@ -70,20 +106,28 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
     
     double sampleRate = asbd ? asbd->mSampleRate : 44100.0;
     NSUInteger channels = asbd ? asbd->mChannelsPerFrame : 2;
-    
-    AudioChannelLayout stereoLayout = {
-        .mChannelLayoutTag = kAudioChannelLayoutTag_Stereo,
-        .mChannelBitmap = 0,
-        .mNumberChannelDescriptions = 0
-    };
-    
-    NSDictionary *audioSettings = @{
+    channels = MAX((NSUInteger)1, channels);
+
+    AudioChannelLayout layout = {0};
+    size_t layoutSize = 0;
+    if (channels == 1) {
+        layout.mChannelLayoutTag = kAudioChannelLayoutTag_Mono;
+        layoutSize = sizeof(AudioChannelLayout);
+    } else if (channels == 2) {
+        layout.mChannelLayoutTag = kAudioChannelLayoutTag_Stereo;
+        layoutSize = sizeof(AudioChannelLayout);
+    }
+
+    NSMutableDictionary *audioSettings = [@{
         AVFormatIDKey: @(kAudioFormatMPEG4AAC),
         AVSampleRateKey: @(sampleRate),
-        AVNumberOfChannelsKey: @(MAX((NSUInteger)1, channels)),
-        AVChannelLayoutKey: [NSData dataWithBytes:&stereoLayout length:sizeof(AudioChannelLayout)],
+        AVNumberOfChannelsKey: @(channels),
         AVEncoderBitRateKey: @(192000)
-    };
+    } mutableCopy];
+
+    if (layoutSize > 0) {
+        audioSettings[AVChannelLayoutKey] = [NSData dataWithBytes:&layout length:layoutSize];
+    }
     
     self.writerInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio outputSettings:audioSettings];
     self.writerInput.expectsMediaDataInRealTime = YES;
@@ -318,4 +362,11 @@ void requestAudioPermission(void (^completion)(BOOL granted)) {
     [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:completion];
 }
 
+NSString *currentStandaloneAudioRecordingPath() {
+    if (!g_audioRecorder) {
+        return nil;
+    }
+    return g_audioRecorder.outputPath;
+}
+
 }

package/src/camera_recorder.mm

@@ -8,6 +8,21 @@
 static AVVideoCodecType const AVVideoCodecTypeVP9 = @"vp09";
 #endif
 
+static BOOL MRAllowContinuityCamera() {
+    static dispatch_once_t onceToken;
+    static BOOL allowContinuity = NO;
+    dispatch_once(&onceToken, ^{
+        id continuityKey = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSCameraUseContinuityCameraDeviceType"];
+        if ([continuityKey respondsToSelector:@selector(boolValue)] && [continuityKey boolValue]) {
+            allowContinuity = YES;
+        }
+        if (!allowContinuity && getenv("ALLOW_CONTINUITY_CAMERA")) {
+            allowContinuity = YES;
+        }
+    });
+    return allowContinuity;
+}
+
 static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     if (!device) {
         return NO;
@@ -27,16 +42,28 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     BOOL nameMentionsContinuity = [localizedName rangeOfString:@"Continuity" options:NSCaseInsensitiveSearch].location != NSNotFound ||
                                   [modelId rangeOfString:@"Continuity" options:NSCaseInsensitiveSearch].location != NSNotFound;
     
-    if ([deviceType isEqualToString:AVCaptureDeviceTypeExternal] && nameMentionsContinuity) {
-        return YES;
+    if (@available(macOS 14.0, *)) {
+        if ([deviceType isEqualToString:AVCaptureDeviceTypeExternal] && nameMentionsContinuity) {
+            return YES;
+        }
     }
     
-    if ([deviceType isEqualToString:AVCaptureDeviceTypeExternal] &&
-        [manufacturer rangeOfString:@"Apple" options:NSCaseInsensitiveSearch].location != NSNotFound &&
-        nameMentionsContinuity) {
+    if ([deviceType isEqualToString:AVCaptureDeviceTypeExternalUnknown] && nameMentionsContinuity) {
         return YES;
     }
     
+    BOOL isApple = [manufacturer rangeOfString:@"Apple" options:NSCaseInsensitiveSearch].location != NSNotFound;
+    if (isApple && nameMentionsContinuity) {
+        if (@available(macOS 14.0, *)) {
+            if ([deviceType isEqualToString:AVCaptureDeviceTypeExternal]) {
+                return YES;
+            }
+        }
+        if ([deviceType isEqualToString:AVCaptureDeviceTypeExternalUnknown]) {
+            return YES;
+        }
+    }
+    
     return NO;
 }
 
@@ -80,14 +107,21 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     NSMutableArray<NSDictionary *> *devicesInfo = [NSMutableArray array];
     
     NSMutableArray<AVCaptureDeviceType> *deviceTypes = [NSMutableArray array];
-    [deviceTypes addObject:AVCaptureDeviceTypeExternalUnknown];
+    BOOL allowContinuity = MRAllowContinuityCamera();
+    
     if (@available(macOS 10.15, *)) {
         [deviceTypes addObject:AVCaptureDeviceTypeBuiltInWideAngleCamera];
+    } else {
+        [deviceTypes addObject:AVCaptureDeviceTypeBuiltInWideAngleCamera];
+    }
+    
+    if (allowContinuity) {
         if (@available(macOS 14.0, *)) {
             [deviceTypes addObject:AVCaptureDeviceTypeContinuityCamera];
+            [deviceTypes addObject:AVCaptureDeviceTypeExternal];
+        } else {
+            [deviceTypes addObject:AVCaptureDeviceTypeExternalUnknown];
         }
-    } else {
-        [deviceTypes addObject:AVCaptureDeviceTypeBuiltInWideAngleCamera];
     }
     
     AVCaptureDeviceDiscoverySession *discoverySession =
@@ -97,6 +131,10 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     
     for (AVCaptureDevice *device in discoverySession.devices) {
         BOOL continuityCamera = MRIsContinuityCamera(device);
+        if (continuityCamera && !allowContinuity) {
+            // Skip Continuity cameras when entitlement/env flag is missing
+            continue;
+        }
         
         // Determine the best (maximum) resolution format for this device
         CMVideoDimensions bestDimensions = {0, 0};
@@ -264,12 +302,25 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
             }
         }
         
-        if (bestRange) {
-            double clampedRate = MIN(bestRange.maxFrameRate, MAX(bestRange.minFrameRate, targetFrameRate));
-            CMTime frameDuration = CMTimeMake(1, (int32_t)round(clampedRate));
-            device.activeVideoMinFrameDuration = frameDuration;
-            device.activeVideoMaxFrameDuration = frameDuration;
+    if (bestRange) {
+        double clampedRate = MIN(bestRange.maxFrameRate, MAX(bestRange.minFrameRate, targetFrameRate));
+        double durationSeconds = clampedRate > 0.0 ? (1.0 / clampedRate) : CMTimeGetSeconds(bestRange.maxFrameDuration);
+        int32_t preferredTimescale = bestRange.minFrameDuration.timescale > 0 ? bestRange.minFrameDuration.timescale : 600;
+        CMTime desiredDuration = CMTimeMakeWithSeconds(durationSeconds, preferredTimescale);
+        
+        if (!CMTIME_IS_NUMERIC(desiredDuration)) {
+            desiredDuration = bestRange.maxFrameDuration;
+        }
+        
+        if (CMTimeCompare(desiredDuration, bestRange.minFrameDuration) < 0) {
+            desiredDuration = bestRange.minFrameDuration;
+        } else if (CMTimeCompare(desiredDuration, bestRange.maxFrameDuration) > 0) {
+            desiredDuration = bestRange.maxFrameDuration;
         }
+        
+        device.activeVideoMinFrameDuration = desiredDuration;
+        device.activeVideoMaxFrameDuration = desiredDuration;
+    }
     } @catch (NSException *exception) {
         if (error) {
             NSDictionary *userInfo = @{
@@ -298,6 +349,7 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     
     NSString *extension = outputURL.pathExtension.lowercaseString;
     BOOL wantsWebM = [extension isEqualToString:@"webm"];
+    NSString *originalPath = outputURL.path ?: @"";
     
     NSString *codec = AVVideoCodecTypeH264;
     AVFileType fileType = AVFileTypeQuickTimeMovie;
@@ -315,7 +367,42 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     }
     
     NSError *writerError = nil;
-    self.assetWriter = [[AVAssetWriter alloc] initWithURL:outputURL fileType:fileType error:&writerError];
+    @try {
+        self.assetWriter = [[AVAssetWriter alloc] initWithURL:outputURL fileType:fileType error:&writerError];
+    } @catch (NSException *exception) {
+        NSDictionary *info = @{
+            NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize asset writer"
+        };
+        writerError = [NSError errorWithDomain:@"CameraRecorder" code:-100 userInfo:info];
+        self.assetWriter = nil;
+    }
+    
+    if ((!self.assetWriter || writerError) && wantsWebM) {
+        MRLog(@"⚠️ CameraRecorder: WebM writer unavailable (%@) – falling back to QuickTime container", writerError.localizedDescription);
+        codec = AVVideoCodecTypeH264;
+        fileType = AVFileTypeQuickTimeMovie;
+        webMSupported = NO;
+        writerError = nil;
+        NSString *fallbackPath = [[originalPath stringByDeletingPathExtension] stringByAppendingPathExtension:@"mov"];
+        if (!fallbackPath || [fallbackPath length] == 0) {
+            fallbackPath = [originalPath stringByAppendingString:@".mov"];
+        }
+        [[NSFileManager defaultManager] removeItemAtPath:fallbackPath error:nil];
+        NSURL *fallbackURL = [NSURL fileURLWithPath:fallbackPath];
+        self.outputPath = fallbackPath;
+        @try {
+            self.assetWriter = [[AVAssetWriter alloc] initWithURL:fallbackURL fileType:fileType error:&writerError];
+        } @catch (NSException *exception) {
+            NSDictionary *info = @{
+                NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize asset writer"
+            };
+            writerError = [NSError errorWithDomain:@"CameraRecorder" code:-100 userInfo:info];
+            self.assetWriter = nil;
+        }
+        outputURL = fallbackURL;
+    } else {
+        self.outputPath = originalPath;
+    }
     
     if (!self.assetWriter || writerError) {
         if (error) {
@@ -324,7 +411,6 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         return NO;
     }
     
-    // On fallback, if WebM was requested but not supported, log and switch extension to .mov
     if (wantsWebM && !webMSupported) {
         MRLog(@"ℹ️ CameraRecorder: WebM unavailable, storing data in QuickTime container");
     }
@@ -349,7 +435,6 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         AVVideoCompressionPropertiesKey: compressionProps
     };
     
-    // Video-only writer input (camera recordings remain silent by design)
     self.assetWriterInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo
                                                                outputSettings:videoSettings];
     self.assetWriterInput.expectsMediaDataInRealTime = YES;
@@ -444,26 +529,15 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         return NO;
     }
 
-    BOOL isContinuityCamera = MRIsContinuityCamera(device);
-    if (isContinuityCamera) {
-        id continuityKey = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSCameraUseContinuityCameraDeviceType"];
-        BOOL allowContinuity = NO;
-        if ([continuityKey respondsToSelector:@selector(boolValue)]) {
-            allowContinuity = [continuityKey boolValue];
-        }
-        if (!allowContinuity && getenv("ALLOW_CONTINUITY_CAMERA")) {
-            allowContinuity = YES;
-        }
-        if (!allowContinuity) {
-            if (error) {
-                NSDictionary *userInfo = @{
-                    NSLocalizedDescriptionKey: @"Continuity Camera requires NSCameraUseContinuityCameraDeviceType=true in Info.plist"
-                };
-                *error = [NSError errorWithDomain:@"CameraRecorder" code:-5 userInfo:userInfo];
-            }
-            MRLog(@"⚠️ Continuity Camera access denied - missing Info.plist entitlement");
-            return NO;
+    if (MRIsContinuityCamera(device) && !MRAllowContinuityCamera()) {
+        if (error) {
+            NSDictionary *userInfo = @{
+                NSLocalizedDescriptionKey: @"Continuity Camera requires NSCameraUseContinuityCameraDeviceType=true in Info.plist"
+            };
+            *error = [NSError errorWithDomain:@"CameraRecorder" code:-5 userInfo:userInfo];
         }
+        MRLog(@"⚠️ Continuity Camera access denied - missing Info.plist entitlement");
+        return NO;
     }
     
     int32_t width = 0;
@@ -521,9 +595,12 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     AVCaptureConnection *connection = [self.videoOutput connectionWithMediaType:AVMediaTypeVideo];
     if (connection) {
         if (connection.isVideoOrientationSupported) {
-            connection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
+            connection.videoOrientation = AVCaptureVideoOrientationPortrait;
         }
         if (connection.isVideoMirroringSupported && device.position == AVCaptureDevicePositionFront) {
+            if ([connection respondsToSelector:@selector(setAutomaticallyAdjustsVideoMirroring:)]) {
+                connection.automaticallyAdjustsVideoMirroring = NO;
+            }
             connection.videoMirrored = YES;
         }
     }
@@ -651,17 +728,13 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 extern "C" {
 
 NSArray<NSDictionary *> *listCameraDevices() {
-    @autoreleasepool {
-        return [CameraRecorder availableCameraDevices];
-    }
+    return [CameraRecorder availableCameraDevices];
 }
 
 bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error) {
-    @autoreleasepool {
-        return [[CameraRecorder sharedRecorder] startRecordingWithDeviceId:deviceId
-                                                                outputPath:outputPath
-                                                                     error:error];
-    }
+    return [[CameraRecorder sharedRecorder] startRecordingWithDeviceId:deviceId
+                                                            outputPath:outputPath
+                                                                 error:error];
 }
 
 bool stopCameraRecording() {
@@ -674,4 +747,8 @@ bool isCameraRecording() {
     return [CameraRecorder sharedRecorder].isRecording;
 }
 
+NSString *currentCameraRecordingPath() {
+    return [CameraRecorder sharedRecorder].outputPath;
+}
+
 }

package/src/cursor_tracker.mm

@@ -1088,43 +1088,13 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
 
             // Check if point is within this display
             if (isInBounds) {
-                // Get physical dimensions
-                CGImageRef testImage = CGDisplayCreateImage(displayID);
-                CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
-                CGImageRelease(testImage);
-
-                CGSize actualPhysicalSize = imageSize;
-                CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(displayID, NULL);
-                if (displayModes) {
-                    CFIndex modeCount = CFArrayGetCount(displayModes);
-                    CGSize maxResolution = CGSizeMake(0, 0);
-
-                    for (CFIndex i = 0; i < modeCount; i++) {
-                        CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
-                        CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
-
-                        if (modeSize.width > maxResolution.width ||
-                            (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
-                            maxResolution = modeSize;
-                        }
-                    }
-
-                    if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
-                        actualPhysicalSize = maxResolution;
-                    } else {
-                        actualPhysicalSize = imageSize;
-                    }
-
-                    CFRelease(displayModes);
-                } else {
-                    actualPhysicalSize = imageSize;
-                }
-
+                // Compute physical dimensions using pixel counts to avoid heavy APIs
                 CGSize logicalSize = displayBounds.size;
-                CGSize reportedPhysicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
+                CGSize actualPhysicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
+                CGSize reportedPhysicalSize = actualPhysicalSize;
 
-                CGFloat scaleX = actualPhysicalSize.width / logicalSize.width;
-                CGFloat scaleY = actualPhysicalSize.height / logicalSize.height;
+                CGFloat scaleX = logicalSize.width > 0 ? actualPhysicalSize.width / logicalSize.width : 1.0;
+                CGFloat scaleY = logicalSize.height > 0 ? actualPhysicalSize.height / logicalSize.height : 1.0;
                 CGFloat scaleFactor = MAX(scaleX, scaleY);
                 
                 return @{
@@ -1141,36 +1111,15 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
         CGDirectDisplayID mainDisplay = CGMainDisplayID();
         CGRect displayBounds = CGDisplayBounds(mainDisplay);
 
-        CGImageRef testImage = CGDisplayCreateImage(mainDisplay);
-        CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
-        CGImageRelease(testImage);
-
-        CGSize actualPhysicalSize = imageSize;
-        CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(mainDisplay, NULL);
-        if (displayModes) {
-            CFIndex modeCount = CFArrayGetCount(displayModes);
-            CGSize maxResolution = CGSizeMake(0, 0);
-
-            for (CFIndex i = 0; i < modeCount; i++) {
-                CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
-                CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
-
-                if (modeSize.width > maxResolution.width ||
-                    (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
-                    maxResolution = modeSize;
-                }
-            }
-
-            if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
-                actualPhysicalSize = maxResolution;
-            }
-
-            CFRelease(displayModes);
+        CGSize logicalSize = displayBounds.size;
+        CGSize actualPhysicalSize = CGSizeMake(CGDisplayPixelsWide(mainDisplay), CGDisplayPixelsHigh(mainDisplay));
+        CGFloat scaleFactor = 1.0;
+        if (logicalSize.width > 0 && logicalSize.height > 0) {
+            CGFloat scaleX = actualPhysicalSize.width / logicalSize.width;
+            CGFloat scaleY = actualPhysicalSize.height / logicalSize.height;
+            scaleFactor = MAX(scaleX, scaleY);
         }
 
-        CGSize logicalSize = displayBounds.size;
-        CGFloat scaleFactor = MAX(actualPhysicalSize.width / logicalSize.width, actualPhysicalSize.height / logicalSize.height);
-        
         return @{
             @"displayID": @(mainDisplay),
             @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],

package/src/mac_recorder.mm

@@ -26,12 +26,16 @@ extern "C" {
     bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
     bool stopCameraRecording();
     bool isCameraRecording();
+    NSString *currentCameraRecordingPath();
+    NSString *currentStandaloneAudioRecordingPath();
 
     NSArray<NSDictionary *> *listAudioCaptureDevices();
     bool startStandaloneAudioRecording(NSString *outputPath, NSString *preferredDeviceId, NSError **error);
     bool stopStandaloneAudioRecording();
     bool isStandaloneAudioRecording();
     bool hasAudioPermission();
+
+    NSString *ScreenCaptureKitCurrentAudioPath(void);
 }
 
 // Cursor tracker function declarations
@@ -56,7 +60,7 @@ static bool g_isRecording = false;
 static bool g_usingStandaloneAudio = false;
 
 static bool startCameraIfRequested(bool captureCamera,
-                                   NSString *cameraOutputPath,
+                                   NSString **cameraOutputPathRef,
                                    NSString *cameraDeviceId,
                                    const std::string &screenOutputPath,
                                    int64_t sessionTimestampMs) {
@@ -64,7 +68,7 @@ static bool startCameraIfRequested(bool captureCamera,
         return true;
     }
     
-    NSString *resolvedOutputPath = cameraOutputPath;
+    NSString *resolvedOutputPath = cameraOutputPathRef ? *cameraOutputPathRef : nil;
     if (!resolvedOutputPath || [resolvedOutputPath length] == 0) {
         NSString *screenPath = [NSString stringWithUTF8String:screenOutputPath.c_str()];
         NSString *directory = nil;
@@ -91,6 +95,13 @@ static bool startCameraIfRequested(bool captureCamera,
         }
         return false;
     }
+    NSString *actualPath = currentCameraRecordingPath();
+    if (actualPath && [actualPath length] > 0) {
+        resolvedOutputPath = actualPath;
+        if (cameraOutputPathRef) {
+            *cameraOutputPathRef = actualPath;
+        }
+    }
     
     MRLog(@"🎥 Camera recording started (output: %@)", resolvedOutputPath);
     return true;
@@ -396,7 +407,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                             MRLog(@"🎬 RECORDING METHOD: ScreenCaptureKit");
                             MRLog(@"✅ ScreenCaptureKit recording started successfully");
                             
-                            if (!startCameraIfRequested(captureCamera, cameraOutputPath, cameraDeviceId, outputPath, sessionTimestamp)) {
+                            if (!startCameraIfRequested(captureCamera, &cameraOutputPath, cameraDeviceId, outputPath, sessionTimestamp)) {
                                 MRLog(@"❌ Camera start failed - stopping ScreenCaptureKit session");
                                 [ScreenCaptureKitRecorder stopRecording];
                                 g_isRecording = false;
@@ -474,7 +485,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                 MRLog(@"🎥 RECORDING METHOD: AVFoundation");
                 MRLog(@"✅ AVFoundation recording started successfully");
                 
-                if (!startCameraIfRequested(captureCamera, cameraOutputPath, cameraDeviceId, outputPath, sessionTimestamp)) {
+                if (!startCameraIfRequested(captureCamera, &cameraOutputPath, cameraDeviceId, outputPath, sessionTimestamp)) {
                     MRLog(@"❌ Camera start failed - stopping AVFoundation session");
                     stopAVFoundationRecording();
                     g_isRecording = false;
@@ -724,92 +735,94 @@ Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
     Napi::Array result = Napi::Array::New(env);
     
     @try {
-        NSArray<NSDictionary *> *devices = listCameraDevices();
-        if (!devices) {
-            return result;
-        }
-        
-        NSUInteger index = 0;
-        for (id entry in devices) {
-            if (![entry isKindOfClass:[NSDictionary class]]) {
-                continue;
-            }
-            
-            NSDictionary *camera = (NSDictionary *)entry;
-            Napi::Object cameraObj = Napi::Object::New(env);
-            
-            NSString *identifier = camera[@"id"];
-            NSString *name = camera[@"name"];
-            NSString *model = camera[@"model"];
-            NSString *manufacturer = camera[@"manufacturer"];
-            NSString *position = camera[@"position"];
-            NSNumber *transportType = camera[@"transportType"];
-            NSNumber *isConnected = camera[@"isConnected"];
-            NSNumber *hasFlash = camera[@"hasFlash"];
-            NSNumber *supportsDepth = camera[@"supportsDepth"];
-            
-            if (identifier && [identifier isKindOfClass:[NSString class]]) {
-                cameraObj.Set("id", Napi::String::New(env, [identifier UTF8String]));
-            } else {
-                cameraObj.Set("id", Napi::String::New(env, ""));
-            }
-            
-            if (name && [name isKindOfClass:[NSString class]]) {
-                cameraObj.Set("name", Napi::String::New(env, [name UTF8String]));
-            } else {
-                cameraObj.Set("name", Napi::String::New(env, "Unknown Camera"));
-            }
-            
-            if (model && [model isKindOfClass:[NSString class]]) {
-                cameraObj.Set("model", Napi::String::New(env, [model UTF8String]));
-            }
-            
-            if (manufacturer && [manufacturer isKindOfClass:[NSString class]]) {
-                cameraObj.Set("manufacturer", Napi::String::New(env, [manufacturer UTF8String]));
+        @autoreleasepool {
+            NSArray<NSDictionary *> *devices = listCameraDevices();
+            if (!devices) {
+                return result;
             }
             
-            if (position && [position isKindOfClass:[NSString class]]) {
-                cameraObj.Set("position", Napi::String::New(env, [position UTF8String]));
-            }
-            
-            if (transportType && [transportType isKindOfClass:[NSNumber class]]) {
-                cameraObj.Set("transportType", Napi::Number::New(env, [transportType integerValue]));
-            }
-            
-            if (isConnected && [isConnected isKindOfClass:[NSNumber class]]) {
-                cameraObj.Set("isConnected", Napi::Boolean::New(env, [isConnected boolValue]));
-            }
-            
-            if (hasFlash && [hasFlash isKindOfClass:[NSNumber class]]) {
-                cameraObj.Set("hasFlash", Napi::Boolean::New(env, [hasFlash boolValue]));
-            }
-            
-            if (supportsDepth && [supportsDepth isKindOfClass:[NSNumber class]]) {
-                cameraObj.Set("supportsDepth", Napi::Boolean::New(env, [supportsDepth boolValue]));
-            }
-            
-            NSDictionary *maxResolution = camera[@"maxResolution"];
-            if (maxResolution && [maxResolution isKindOfClass:[NSDictionary class]]) {
-                Napi::Object maxResObj = Napi::Object::New(env);
+            NSUInteger index = 0;
+            for (id entry in devices) {
+                if (![entry isKindOfClass:[NSDictionary class]]) {
+                    continue;
+                }
+                
+                NSDictionary *camera = (NSDictionary *)entry;
+                Napi::Object cameraObj = Napi::Object::New(env);
                 
-                NSNumber *width = maxResolution[@"width"];
-                NSNumber *height = maxResolution[@"height"];
-                NSNumber *frameRate = maxResolution[@"maxFrameRate"];
+                NSString *identifier = camera[@"id"];
+                NSString *name = camera[@"name"];
+                NSString *model = camera[@"model"];
+                NSString *manufacturer = camera[@"manufacturer"];
+                NSString *position = camera[@"position"];
+                NSNumber *transportType = camera[@"transportType"];
+                NSNumber *isConnected = camera[@"isConnected"];
+                NSNumber *hasFlash = camera[@"hasFlash"];
+                NSNumber *supportsDepth = camera[@"supportsDepth"];
+                
+                if (identifier && [identifier isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("id", Napi::String::New(env, [identifier UTF8String]));
+                } else {
+                    cameraObj.Set("id", Napi::String::New(env, ""));
+                }
                 
-                if (width && [width isKindOfClass:[NSNumber class]]) {
-                    maxResObj.Set("width", Napi::Number::New(env, [width integerValue]));
+                if (name && [name isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("name", Napi::String::New(env, [name UTF8String]));
+                } else {
+                    cameraObj.Set("name", Napi::String::New(env, "Unknown Camera"));
                 }
-                if (height && [height isKindOfClass:[NSNumber class]]) {
-                    maxResObj.Set("height", Napi::Number::New(env, [height integerValue]));
+                
+                if (model && [model isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("model", Napi::String::New(env, [model UTF8String]));
                 }
-                if (frameRate && [frameRate isKindOfClass:[NSNumber class]]) {
-                    maxResObj.Set("maxFrameRate", Napi::Number::New(env, [frameRate doubleValue]));
+                
+                if (manufacturer && [manufacturer isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("manufacturer", Napi::String::New(env, [manufacturer UTF8String]));
                 }
                 
-                cameraObj.Set("maxResolution", maxResObj);
+                if (position && [position isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("position", Napi::String::New(env, [position UTF8String]));
+                }
+                
+                if (transportType && [transportType isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("transportType", Napi::Number::New(env, [transportType integerValue]));
+                }
+                
+                if (isConnected && [isConnected isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("isConnected", Napi::Boolean::New(env, [isConnected boolValue]));
+                }
+                
+                if (hasFlash && [hasFlash isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("hasFlash", Napi::Boolean::New(env, [hasFlash boolValue]));
+                }
+                
+                if (supportsDepth && [supportsDepth isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("supportsDepth", Napi::Boolean::New(env, [supportsDepth boolValue]));
+                }
+                
+                NSDictionary *maxResolution = camera[@"maxResolution"];
+                if (maxResolution && [maxResolution isKindOfClass:[NSDictionary class]]) {
+                    Napi::Object maxResObj = Napi::Object::New(env);
+                    
+                    NSNumber *width = maxResolution[@"width"];
+                    NSNumber *height = maxResolution[@"height"];
+                    NSNumber *frameRate = maxResolution[@"maxFrameRate"];
+                    
+                    if (width && [width isKindOfClass:[NSNumber class]]) {
+                        maxResObj.Set("width", Napi::Number::New(env, [width integerValue]));
+                    }
+                    if (height && [height isKindOfClass:[NSNumber class]]) {
+                        maxResObj.Set("height", Napi::Number::New(env, [height integerValue]));
+                    }
+                    if (frameRate && [frameRate isKindOfClass:[NSNumber class]]) {
+                        maxResObj.Set("maxFrameRate", Napi::Number::New(env, [frameRate doubleValue]));
+                    }
+                    
+                    cameraObj.Set("maxResolution", maxResObj);
+                }
+                
+                result[index++] = cameraObj;
             }
-            
-            result[index++] = cameraObj;
         }
         
         return result;
@@ -819,6 +832,43 @@ Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
     }
 }
 
+Napi::Value GetCameraRecordingPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    @try {
+        NSString *path = currentCameraRecordingPath();
+        if (!path || [path length] == 0) {
+            return env.Null();
+        }
+        return Napi::String::New(env, [path UTF8String]);
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception while reading camera output path: %@", exception.reason);
+        return env.Null();
+    }
+}
+
+Napi::Value GetAudioRecordingPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    @try {
+        NSString *path = nil;
+        if (@available(macOS 12.3, *)) {
+            path = ScreenCaptureKitCurrentAudioPath();
+        }
+        if ([path isKindOfClass:[NSArray class]]) {
+            path = [(NSArray *)path firstObject];
+        }
+        if (!path || [path length] == 0) {
+            path = currentStandaloneAudioRecordingPath();
+        }
+        if (!path || [path length] == 0) {
+            return env.Null();
+        }
+        return Napi::String::New(env, [path UTF8String]);
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception while reading audio output path: %@", exception.reason);
+        return env.Null();
+    }
+}
+
 // NAPI Function: Get Displays
 Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -1222,6 +1272,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
 
     exports.Set(Napi::String::New(env, "getAudioDevices"), Napi::Function::New(env, GetAudioDevices));
     exports.Set(Napi::String::New(env, "getCameraDevices"), Napi::Function::New(env, GetCameraDevices));
+    exports.Set(Napi::String::New(env, "getCameraRecordingPath"), Napi::Function::New(env, GetCameraRecordingPath));
+    exports.Set(Napi::String::New(env, "getAudioRecordingPath"), Napi::Function::New(env, GetAudioRecordingPath));
     exports.Set(Napi::String::New(env, "getDisplays"), Napi::Function::New(env, GetDisplays));
     exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, GetWindows));
     exports.Set(Napi::String::New(env, "getRecordingStatus"), Napi::Function::New(env, GetRecordingStatus));

package/src/screen_capture_kit.mm

@@ -19,7 +19,7 @@ static id g_audioStreamOutput = nil;
 
 static AVAssetWriter *g_videoWriter = nil;
 static AVAssetWriterInput *g_videoInput = nil;
-static AVAssetWriterInputPixelBufferAdaptor *g_pixelBufferAdaptor = nil;
+static CFTypeRef g_pixelBufferAdaptorRef = NULL;
 static CMTime g_videoStartTime = kCMTimeInvalid;
 static BOOL g_videoWriterStarted = NO;
 
@@ -34,6 +34,33 @@ static NSInteger g_configuredSampleRate = 48000;
 static NSInteger g_configuredChannelCount = 2;
 
 static void CleanupWriters(void);
+static AVAssetWriterInputPixelBufferAdaptor * _Nullable CurrentPixelBufferAdaptor(void) {
+    if (!g_pixelBufferAdaptorRef) {
+        return nil;
+    }
+    return (__bridge AVAssetWriterInputPixelBufferAdaptor *)g_pixelBufferAdaptorRef;
+}
+
+static NSString *MRNormalizePath(id value) {
+    if (!value || value == (id)kCFNull) {
+        return nil;
+    }
+    if ([value isKindOfClass:[NSString class]]) {
+        return (NSString *)value;
+    }
+    if ([value isKindOfClass:[NSURL class]]) {
+        return [(NSURL *)value path];
+    }
+    if ([value isKindOfClass:[NSArray class]]) {
+        for (id entry in (NSArray *)value) {
+            NSString *candidate = MRNormalizePath(entry);
+            if (candidate.length > 0) {
+                return candidate;
+            }
+        }
+    }
+    return nil;
+}
 
 static void FinishWriter(AVAssetWriter *writer, AVAssetWriterInput *input) {
     if (!writer) {
@@ -57,7 +84,10 @@ static void CleanupWriters(void) {
         FinishWriter(g_videoWriter, g_videoInput);
         g_videoWriter = nil;
         g_videoInput = nil;
-        g_pixelBufferAdaptor = nil;
+        if (g_pixelBufferAdaptorRef) {
+            CFRelease(g_pixelBufferAdaptorRef);
+            g_pixelBufferAdaptorRef = NULL;
+        }
         g_videoWriterStarted = NO;
         g_videoStartTime = kCMTimeInvalid;
     }
@@ -74,6 +104,20 @@ static void CleanupWriters(void) {
 @interface PureScreenCaptureDelegate : NSObject <SCStreamDelegate>
 @end
 
+extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
+    if (!g_audioOutputPath) {
+        return nil;
+    }
+    if ([g_audioOutputPath isKindOfClass:[NSArray class]]) {
+        id first = [(NSArray *)g_audioOutputPath firstObject];
+        if ([first isKindOfClass:[NSString class]]) {
+            return first;
+        }
+        return nil;
+    }
+    return g_audioOutputPath;
+}
+
 @implementation PureScreenCaptureDelegate
 - (void)stream:(SCStream * API_AVAILABLE(macos(12.3)))stream didStopWithError:(NSError *)error API_AVAILABLE(macos(12.3)) {
     MRLog(@"🛑 Pure ScreenCapture stream stopped");
@@ -144,12 +188,27 @@ static void CleanupWriters(void) {
         return;
     }
     
-    if (!g_pixelBufferAdaptor) {
+    AVAssetWriterInputPixelBufferAdaptor *adaptorCandidate = CurrentPixelBufferAdaptor();
+    if ([adaptorCandidate isKindOfClass:[NSArray class]]) {
+        id first = [(NSArray *)adaptorCandidate firstObject];
+        if ([first isKindOfClass:[AVAssetWriterInputPixelBufferAdaptor class]]) {
+            adaptorCandidate = first;
+            if (g_pixelBufferAdaptorRef) {
+                CFRelease(g_pixelBufferAdaptorRef);
+            }
+            g_pixelBufferAdaptorRef = CFBridgingRetain(adaptorCandidate);
+        }
+    }
+    if (![adaptorCandidate isKindOfClass:[AVAssetWriterInputPixelBufferAdaptor class]]) {
+        if (adaptorCandidate) {
+            MRLog(@"⚠️ Pixel buffer adaptor invalid (%@) – skipping frame", NSStringFromClass([adaptorCandidate class]));
+        }
         NSLog(@"❌ Pixel buffer adaptor is nil – cannot append video frames");
         return;
     }
     
-    BOOL appended = [g_pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:presentationTime];
+    AVAssetWriterInputPixelBufferAdaptor *adaptor = adaptorCandidate;
+    BOOL appended = [adaptor appendPixelBuffer:pixelBuffer withPresentationTime:presentationTime];
     if (!appended) {
         NSLog(@"⚠️ Failed appending pixel buffer: %@", g_videoWriter.error);
     }
@@ -211,7 +270,13 @@ static void CleanupWriters(void) {
 @implementation ScreenCaptureKitRecorder
 
 + (BOOL)prepareVideoWriterWithWidth:(NSInteger)width height:(NSInteger)height error:(NSError **)error {
+    MRLog(@"🎬 Preparing video writer %ldx%ld", (long)width, (long)height);
     if (!g_outputPath) {
+        MRLog(@"❌ Video writer failed: missing output path");
+        return NO;
+    }
+    if (width <= 0 || height <= 0) {
+        MRLog(@"❌ Video writer invalid dimensions %ldx%ld", (long)width, (long)height);
         return NO;
     }
     
@@ -220,6 +285,7 @@ static void CleanupWriters(void) {
     
     g_videoWriter = [[AVAssetWriter alloc] initWithURL:outputURL fileType:AVFileTypeQuickTimeMovie error:error];
     if (!g_videoWriter || (error && *error)) {
+        MRLog(@"❌ Failed creating video writer: %@", error && *error ? (*error).localizedDescription : @"unknown");
         return NO;
     }
     
@@ -238,15 +304,16 @@ static void CleanupWriters(void) {
     g_videoInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:videoSettings];
     g_videoInput.expectsMediaDataInRealTime = YES;
     
-    g_pixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:g_videoInput sourcePixelBufferAttributes:@{
+    AVAssetWriterInputPixelBufferAdaptor *pixelAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:g_videoInput sourcePixelBufferAttributes:@{
         (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA),
         (NSString *)kCVPixelBufferWidthKey: @(width),
         (NSString *)kCVPixelBufferHeightKey: @(height),
         (NSString *)kCVPixelBufferCGImageCompatibilityKey: @YES,
         (NSString *)kCVPixelBufferCGBitmapContextCompatibilityKey: @YES
     }];
-    
+
     if (![g_videoWriter canAddInput:g_videoInput]) {
+        MRLog(@"❌ Cannot add video input to writer");
         if (error) {
             *error = [NSError errorWithDomain:@"ScreenCaptureKitRecorder" code:-100 userInfo:@{NSLocalizedDescriptionKey: @"Cannot add video input to writer"}];
         }
@@ -254,9 +321,17 @@ static void CleanupWriters(void) {
     }
     
     [g_videoWriter addInput:g_videoInput];
+    if (g_pixelBufferAdaptorRef) {
+        CFRelease(g_pixelBufferAdaptorRef);
+        g_pixelBufferAdaptorRef = NULL;
+    }
+    if (pixelAdaptor) {
+        g_pixelBufferAdaptorRef = CFBridgingRetain(pixelAdaptor);
+    }
     g_videoWriterStarted = NO;
     g_videoStartTime = kCMTimeInvalid;
-    
+    MRLog(@"✅ Video writer ready %ldx%ld", (long)width, (long)height);
+
     return YES;
 }
 
@@ -280,34 +355,76 @@ static void CleanupWriters(void) {
     g_configuredSampleRate = (NSInteger)asbd->mSampleRate;
     g_configuredChannelCount = asbd->mChannelsPerFrame;
     
-    NSURL *audioURL = [NSURL fileURLWithPath:g_audioOutputPath];
+    NSString *originalPath = g_audioOutputPath ?: @"";
+    NSURL *audioURL = [NSURL fileURLWithPath:originalPath];
     [[NSFileManager defaultManager] removeItemAtURL:audioURL error:nil];
     
     NSError *writerError = nil;
-    AVFileType fileType = AVFileTypeQuickTimeMovie;
+    AVFileType requestedFileType = AVFileTypeQuickTimeMovie;
+    BOOL requestedWebM = NO;
     if (@available(macOS 15.0, *)) {
-        fileType = @"public.webm";
+        requestedFileType = @"public.webm";
+        requestedWebM = YES;
+    }
+    
+    @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) && requestedWebM) {
+        MRLog(@"⚠️ ScreenCaptureKit audio writer unavailable (%@) – falling back to QuickTime container", writerError.localizedDescription);
+        NSString *fallbackPath = [[originalPath stringByDeletingPathExtension] stringByAppendingPathExtension:@"mov"];
+        if (!fallbackPath || [fallbackPath length] == 0) {
+            fallbackPath = [originalPath stringByAppendingString:@".mov"];
+        }
+        [[NSFileManager defaultManager] removeItemAtPath:fallbackPath error:nil];
+        NSURL *fallbackURL = [NSURL fileURLWithPath:fallbackPath];
+        g_audioOutputPath = fallbackPath;
+        writerError = nil;
+        @try {
+            g_audioWriter = [[AVAssetWriter alloc] initWithURL:fallbackURL fileType:AVFileTypeQuickTimeMovie error:&writerError];
+        } @catch (NSException *exception) {
+            NSDictionary *info = @{
+                NSLocalizedDescriptionKey: exception.reason ?: @"Failed to initialize audio writer"
+            };
+            writerError = [NSError errorWithDomain:@"ScreenCaptureKitRecorder" code:-202 userInfo:info];
+            g_audioWriter = nil;
+        }
+        audioURL = fallbackURL;
     }
     
-    g_audioWriter = [[AVAssetWriter alloc] initWithURL:audioURL fileType:fileType error:&writerError];
     if (!g_audioWriter || writerError) {
         NSLog(@"❌ Failed to create audio writer: %@", writerError);
         return NO;
     }
     
-    AudioChannelLayout stereoLayout = {
-        .mChannelLayoutTag = kAudioChannelLayoutTag_Stereo,
-        .mChannelBitmap = 0,
-        .mNumberChannelDescriptions = 0
-    };
-    
-    NSDictionary *audioSettings = @{
+    NSInteger channelCount = MAX(1, g_configuredChannelCount);
+    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: @(g_configuredSampleRate),
-        AVNumberOfChannelsKey: @(MAX(1, g_configuredChannelCount)),
-        AVChannelLayoutKey: [NSData dataWithBytes:&stereoLayout length:sizeof(AudioChannelLayout)],
+        AVNumberOfChannelsKey: @(channelCount),
         AVEncoderBitRateKey: @(192000)
-    };
+    } mutableCopy];
+
+    if (layoutSize > 0) {
+        audioSettings[AVChannelLayoutKey] = [NSData dataWithBytes:&layout length:layoutSize];
+    }
     
     g_audioInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio outputSettings:audioSettings];
     g_audioInput.expectsMediaDataInRealTime = YES;
@@ -356,7 +473,7 @@ static void CleanupWriters(void) {
     NSNumber *includeMicrophone = config[@"includeMicrophone"];
     NSNumber *includeSystemAudio = config[@"includeSystemAudio"];
     NSString *microphoneDeviceId = config[@"microphoneDeviceId"];
-    NSString *audioOutputPath = config[@"audioOutputPath"];
+    NSString *audioOutputPath = MRNormalizePath(config[@"audioOutputPath"]);
     NSNumber *sessionTimestampNumber = config[@"sessionTimestamp"];
     
     MRLog(@"🎬 Starting PURE ScreenCaptureKit recording (NO AVFoundation)");
@@ -680,6 +797,10 @@ static void CleanupWriters(void) {
         g_audioStreamOutput = nil;
         g_videoQueue = nil;
         g_audioQueue = nil;
+        if (g_pixelBufferAdaptorRef) {
+            CFRelease(g_pixelBufferAdaptorRef);
+            g_pixelBufferAdaptorRef = NULL;
+        }
         g_audioOutputPath = nil;
         g_shouldCaptureAudio = NO;