node-mac-recorder 2.21.0 → 2.21.2

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.2",
 	"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)],