node-mac-recorder 2.16.31 → 2.16.33

package/cursor-debug-test.js

@@ -0,0 +1,60 @@
+const MacRecorder = require('./index.js');
+
+console.log('🔍 Debugging cursor coordinate scaling issue...\n');
+
+const recorder = new MacRecorder();
+
+async function testCursorScaling() {
+    console.log('Getting display info...');
+    const displays = await recorder.getDisplays();
+    
+    displays.forEach((display, index) => {
+        console.log(`Display ${index}:`);
+        console.log(`  Resolution: ${display.resolution}`);
+        console.log(`  Position: (${display.x}, ${display.y})`);
+        console.log(`  Primary: ${display.isPrimary}`);
+        console.log(`  ID: ${display.id}`);
+    });
+    
+    console.log('\n🎯 Please move your mouse to different corners and press Enter...');
+    console.log('This will help us understand the coordinate mapping issue.\n');
+    
+    const readline = require('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    
+    let testCount = 0;
+    const testPositions = [
+        'Top-Left corner of the display',
+        'Top-Right corner of the display', 
+        'Bottom-Left corner of the display',
+        'Bottom-Right corner of the display',
+        'Center of the display'
+    ];
+    
+    function nextTest() {
+        if (testCount >= testPositions.length) {
+            console.log('\n✅ Test completed!');
+            rl.close();
+            process.exit(0);
+            return;
+        }
+        
+        console.log(`\n📍 Test ${testCount + 1}: Move mouse to ${testPositions[testCount]} and press Enter:`);
+        rl.question('', () => {
+            const position = recorder.getCursorPosition();
+            console.log(`   Raw cursor position: (${position.rawX || 'N/A'}, ${position.rawY || 'N/A'})`);
+            console.log(`   Logical cursor position: (${position.x}, ${position.y})`);
+            console.log(`   Scale factor: ${position.scaleFactor || 'N/A'}x`);
+            
+            testCount++;
+            nextTest();
+        });
+    }
+    
+    nextTest();
+}
+
+testCursorScaling().catch(console.error);

package/cursor-macbook-test.js

@@ -0,0 +1,63 @@
+const MacRecorder = require('./index.js');
+
+async function testMacBookCursor() {
+    console.log('🖥️  Testing cursor on MacBook internal display...\n');
+    
+    const recorder = new MacRecorder();
+    
+    // Get displays
+    const displays = await recorder.getDisplays();
+    console.log('📺 Available displays:');
+    displays.forEach((display, index) => {
+        console.log(`   Display ${index}: ${display.resolution} at (${display.x}, ${display.y}) - Primary: ${display.isPrimary}`);
+    });
+    
+    console.log('\n🎯 Move your mouse to the PRIMARY MacBook display and press any key...');
+    console.log('(Make sure cursor is on the built-in MacBook screen, not external monitor)\n');
+    
+    // Wait for keypress
+    await new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.once('data', () => {
+            process.stdin.setRawMode(false);
+            resolve();
+        });
+    });
+    
+    console.log('🔍 Testing cursor position on MacBook display:');
+    for (let i = 0; i < 3; i++) {
+        const position = recorder.getCursorPosition();
+        console.log(`\n   Test ${i+1}:`);
+        console.log(`     Cursor: (${position.x}, ${position.y})`);
+        console.log(`     Cursor type: ${position.cursorType}`);
+        
+        // Check which display cursor is on
+        const primaryDisplay = displays.find(d => d.isPrimary);
+        if (primaryDisplay) {
+            const isOnPrimary = position.x >= primaryDisplay.x && 
+                               position.x < primaryDisplay.x + parseInt(primaryDisplay.resolution.split('x')[0]) &&
+                               position.y >= primaryDisplay.y && 
+                               position.y < primaryDisplay.y + parseInt(primaryDisplay.resolution.split('x')[1]);
+            
+            console.log(`     On primary display: ${isOnPrimary ? '✅ YES' : '❌ NO'}`);
+        }
+        
+        if (position.scaleFactor) {
+            console.log(`     Scale factor: ${position.scaleFactor}x`);
+            if (position.displayInfo) {
+                console.log(`     Display logical: ${position.displayInfo.logicalWidth}x${position.displayInfo.logicalHeight}`);
+                console.log(`     Display physical: ${position.displayInfo.physicalWidth}x${position.displayInfo.physicalHeight}`);
+                console.log(`     Raw cursor: (${position.rawX}, ${position.rawY})`);
+            }
+        } else {
+            console.log(`     ⚠️ No scaling info detected`);
+        }
+        
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    
+    process.exit(0);
+}
+
+testMacBookCursor().catch(console.error);

package/cursor-permission-test.js

@@ -0,0 +1,46 @@
+const MacRecorder = require('./index.js');
+
+async function testCursorPermissions() {
+    console.log('🔒 Testing cursor tracking permissions...\n');
+    
+    const recorder = new MacRecorder();
+    
+    // Check permissions first
+    console.log('1. Checking permissions:');
+    const permissions = await recorder.checkPermissions();
+    console.log('   Screen Recording:', permissions.screenRecording ? '✅' : '❌');
+    console.log('   Accessibility:', permissions.accessibility ? '✅' : '❌');
+    console.log('   Microphone:', permissions.microphone ? '✅' : '❌');
+    
+    if (permissions.error) {
+        console.log('   Error:', permissions.error);
+    }
+    
+    console.log('\n2. Testing direct cursor position (no capture):');
+    for (let i = 0; i < 5; i++) {
+        try {
+            const position = recorder.getCursorPosition();
+            console.log(`   Position ${i+1}: (${position.x}, ${position.y}) - ${position.cursorType}`);
+            
+            if (position.scaleFactor) {
+                console.log(`     Scale: ${position.scaleFactor}x, Display: (${position.displayInfo?.displayX}, ${position.displayInfo?.displayY})`);
+                console.log(`     Logical: ${position.displayInfo?.logicalWidth}x${position.displayInfo?.logicalHeight}`);
+                console.log(`     Physical: ${position.displayInfo?.physicalWidth}x${position.displayInfo?.physicalHeight}`);
+            }
+            
+            await new Promise(resolve => setTimeout(resolve, 500));
+        } catch (error) {
+            console.error(`   Error getting position ${i+1}:`, error.message);
+        }
+    }
+    
+    console.log('\n3. Testing cursor capture status:');
+    const status = recorder.getCursorCaptureStatus();
+    console.log('   Is Capturing:', status.isCapturing);
+    console.log('   Output File:', status.outputFile);
+    console.log('   Display Info:', status.displayInfo);
+    
+    process.exit(0);
+}
+
+testCursorPermissions().catch(console.error);

package/cursor-scaling-debug.js

@@ -0,0 +1,53 @@
+const MacRecorder = require('./index.js');
+
+async function debugCursorScaling() {
+    console.log('🔍 Debugging cursor scaling detection...\n');
+    
+    const recorder = new MacRecorder();
+    
+    // Get all displays
+    const displays = await recorder.getDisplays();
+    console.log('📺 Available displays:');
+    displays.forEach((display, index) => {
+        console.log(`   Display ${index}: ID=${display.id}, ${display.resolution} at (${display.x}, ${display.y}), Primary: ${display.isPrimary}`);
+    });
+    
+    console.log('\n🎯 Current cursor position analysis:');
+    const position = recorder.getCursorPosition();
+    
+    console.log(`   Logical position: (${position.x}, ${position.y})`);
+    console.log(`   Cursor type: ${position.cursorType}`);
+    console.log(`   Event type: ${position.eventType}`);
+    
+    if (position.scaleFactor) {
+        console.log(`   Scale factor detected: ${position.scaleFactor}x`);
+        if (position.displayInfo) {
+            const info = position.displayInfo;
+            console.log(`   Display bounds: (${info.displayX}, ${info.displayY})`);
+            console.log(`   Logical size: ${info.logicalWidth}x${info.logicalHeight}`);
+            console.log(`   Physical size: ${info.physicalWidth}x${info.physicalHeight}`);
+            console.log(`   Raw position: (${position.rawX}, ${position.rawY})`);
+        }
+    } else {
+        console.log(`   ❌ No scale factor detected`);
+        console.log(`   This could mean:`);
+        console.log(`     - getDisplayScalingInfo() didn't find the correct display`);
+        console.log(`     - Display detection logic needs debugging`);
+    }
+    
+    // Find which display the cursor is on
+    console.log('\n🔍 Manual display detection:');
+    displays.forEach((display, index) => {
+        const inX = position.x >= display.x && position.x < display.x + parseInt(display.resolution.split('x')[0]);
+        const inY = position.y >= display.y && position.y < display.y + parseInt(display.resolution.split('x')[1]);
+        const isInside = inX && inY;
+        
+        console.log(`   Display ${index} (${display.resolution}): ${isInside ? '✅ CURSOR IS HERE' : '❌'}`);
+        console.log(`     Bounds: X(${display.x} - ${display.x + parseInt(display.resolution.split('x')[0])}), Y(${display.y} - ${display.y + parseInt(display.resolution.split('x')[1])})`);
+        console.log(`     Cursor: X(${position.x}), Y(${position.y})`);
+    });
+    
+    process.exit(0);
+}
+
+debugCursorScaling().catch(console.error);

package/cursor-simple-test.js

@@ -0,0 +1,26 @@
+const MacRecorder = require('./index.js');
+
+console.log('🎯 Simple cursor test - Move your mouse to MacBook screen...\n');
+
+const recorder = new MacRecorder();
+
+// Test 10 cursor positions
+for (let i = 0; i < 10; i++) {
+    setTimeout(() => {
+        const position = recorder.getCursorPosition();
+        console.log(`${i+1}. Cursor: (${position.x}, ${position.y}), Scale: ${position.scaleFactor || 'none'}`);
+        
+        if (position.displayInfo && position.scaleFactor > 1.1) {
+            console.log(`   🎉 SCALING DETECTED! ${position.scaleFactor}x`);
+            console.log(`   Logical: ${position.displayInfo.logicalWidth}x${position.displayInfo.logicalHeight}`);
+            console.log(`   Physical: ${position.displayInfo.physicalWidth}x${position.displayInfo.physicalHeight}`);
+            console.log(`   Raw cursor: (${position.rawX}, ${position.rawY})`);
+            process.exit(0);
+        }
+        
+        if (i === 9) {
+            console.log('\n⚠️ No scaling detected. Try moving mouse to MacBook internal display.');
+            process.exit(0);
+        }
+    }, i * 500);
+}

package/index.js

@@ -258,6 +258,9 @@ class MacRecorder extends EventEmitter {
 							y: targetDisplay.y,
 							width: parseInt(targetDisplay.resolution.split("x")[0]),
 							height: parseInt(targetDisplay.resolution.split("x")[1]),
+							// Add scaling information for cursor coordinate transformation
+							logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
+							logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
 						};
 					}
 
@@ -292,6 +295,9 @@ class MacRecorder extends EventEmitter {
 						y: targetDisplay.y,
 						width: parseInt(targetDisplay.resolution.split("x")[0]),
 						height: parseInt(targetDisplay.resolution.split("x")[1]),
+						// Add scaling information for cursor coordinate transformation
+						logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
+						logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
 					};
 				}
 			} catch (error) {
@@ -696,10 +702,32 @@ class MacRecorder extends EventEmitter {
 						let coordinateSystem = "global";
 
 						if (this.cursorDisplayInfo) {
-							// Offset'leri çıkar (display veya window)
-							// Y koordinat dönüşümü başlangıçta yapıldı
-							x = position.x - this.cursorDisplayInfo.x;
-							y = position.y - this.cursorDisplayInfo.y;
+							// CRITICAL FIX: Handle DPR scaling for cursor coordinates
+							// Get scaling information from native cursor position
+							const scaleFactor = position.scaleFactor || 1;
+							const displayInfo = position.displayInfo;
+							
+							// Convert logical cursor position to physical (if recording uses physical coordinates)
+							let physicalX = position.x;
+							let physicalY = position.y;
+							
+							if (scaleFactor > 1.1 && displayInfo) {
+								// Convert to display-relative logical, then to physical
+								const displayRelativeX = position.x - displayInfo.displayX;
+								const displayRelativeY = position.y - displayInfo.displayY;
+								
+								// Scale to physical coordinates
+								const physicalRelativeX = displayRelativeX * scaleFactor;
+								const physicalRelativeY = displayRelativeY * scaleFactor;
+								
+								// Convert back to global physical
+								physicalX = displayInfo.displayX + physicalRelativeX;
+								physicalY = displayInfo.displayY + physicalRelativeY;
+							}
+							
+							// Offset'leri çıkar (display veya window) - use physical coordinates
+							x = physicalX - this.cursorDisplayInfo.x;
+							y = physicalY - this.cursorDisplayInfo.y;
 
 							if (this.cursorDisplayInfo.windowRelative) {
 								// Window-relative koordinatlar

package/package.json

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

package/src/cursor_tracker.mm

@@ -209,17 +209,8 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
             NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
             
-            if (scaleFactor > 1.1) {
-                // Convert to logical coordinates
-                CGFloat displayRelativeX = rawLocation.x - displayBounds.origin.x;
-                CGFloat displayRelativeY = rawLocation.y - displayBounds.origin.y;
-                
-                CGFloat logicalRelativeX = displayRelativeX / scaleFactor;
-                CGFloat logicalRelativeY = displayRelativeY / scaleFactor;
-                
-                location.x = displayBounds.origin.x + logicalRelativeX;
-                location.y = displayBounds.origin.y + logicalRelativeY;
-            }
+            // Keep logical coordinates - no scaling needed here
+            location = rawLocation;
         }
         NSDate *currentDate = [NSDate date];
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
@@ -291,17 +282,8 @@ void cursorTimerCallback() {
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
             NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
             
-            if (scaleFactor > 1.1) {
-                // Convert to logical coordinates
-                CGFloat displayRelativeX = rawLocation.x - displayBounds.origin.x;
-                CGFloat displayRelativeY = rawLocation.y - displayBounds.origin.y;
-                
-                CGFloat logicalRelativeX = displayRelativeX / scaleFactor;
-                CGFloat logicalRelativeY = displayRelativeY / scaleFactor;
-                
-                location.x = displayBounds.origin.x + logicalRelativeX;
-                location.y = displayBounds.origin.y + logicalRelativeY;
-            }
+            // Keep logical coordinates - no scaling needed here
+            location = rawLocation;
         }
         
         NSDate *currentDate = [NSDate date];
@@ -491,37 +473,125 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
             CGDirectDisplayID displayID = displayIDs[i];
             CGRect displayBounds = CGDisplayBounds(displayID);
             
+            NSLog(@"🔍 Display %u: bounds(%.0f,%.0f %.0fx%.0f), cursor(%.0f,%.0f)", 
+                  displayID, displayBounds.origin.x, displayBounds.origin.y, 
+                  displayBounds.size.width, displayBounds.size.height,
+                  globalPoint.x, globalPoint.y);
+            
+            // CRITICAL FIX: Manual bounds check for better coordinate system compatibility
+            BOOL isInBounds = (globalPoint.x >= displayBounds.origin.x && 
+                              globalPoint.x < displayBounds.origin.x + displayBounds.size.width &&
+                              globalPoint.y >= displayBounds.origin.y && 
+                              globalPoint.y < displayBounds.origin.y + displayBounds.size.height);
+            
+            NSLog(@"🔍 Manual bounds check: %s", isInBounds ? "INSIDE" : "OUTSIDE");
+            
             // Check if point is within this display
-            if (CGRectContainsPoint(displayBounds, globalPoint)) {
-                // Get display scaling info
+            if (isInBounds) {
+                // CRITICAL FIX: Get REAL physical dimensions using multiple detection methods
+                // Method 1: CGDisplayCreateImage (may be scaled on some systems)
+                CGImageRef testImage = CGDisplayCreateImage(displayID);
+                CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+                CGImageRelease(testImage);
+                
+                // Method 2: Native display mode detection for true physical resolution
+                CGSize actualPhysicalSize = imageSize;
+                CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(displayID, NULL);
+                if (displayModes) {
+                    CFIndex modeCount = CFArrayGetCount(displayModes);
+                    CGSize maxResolution = CGSizeMake(0, 0);
+                    
+                    // Find the highest resolution mode (native resolution)
+                    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;
+                        }
+                    }
+                    
+                    // Use the max resolution if it's significantly higher than image size
+                    if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
+                        actualPhysicalSize = maxResolution;
+                        NSLog(@"🔍 Using display mode detection: %.0fx%.0f (was %.0fx%.0f)", 
+                              maxResolution.width, maxResolution.height, imageSize.width, imageSize.height);
+                    } else {
+                        actualPhysicalSize = imageSize;
+                        NSLog(@"🔍 Using image size detection: %.0fx%.0f", imageSize.width, imageSize.height);
+                    }
+                    
+                    CFRelease(displayModes);
+                } else {
+                    actualPhysicalSize = imageSize;
+                }
+                
                 CGSize logicalSize = displayBounds.size;
-                CGSize physicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
+                CGSize reportedPhysicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
                 
-                CGFloat scaleX = physicalSize.width / logicalSize.width;
-                CGFloat scaleY = physicalSize.height / logicalSize.height;
+                NSLog(@"🔍 REAL scaling info:");
+                NSLog(@"   Logical: %.0fx%.0f", logicalSize.width, logicalSize.height);
+                NSLog(@"   Reported physical: %.0fx%.0f", reportedPhysicalSize.width, reportedPhysicalSize.height);
+                NSLog(@"   ACTUAL physical: %.0fx%.0f", actualPhysicalSize.width, actualPhysicalSize.height);
+                
+                CGFloat scaleX = actualPhysicalSize.width / logicalSize.width;
+                CGFloat scaleY = actualPhysicalSize.height / logicalSize.height;
                 CGFloat scaleFactor = MAX(scaleX, scaleY);
                 
+                NSLog(@"🔍 REAL scale factors: X=%.2f, Y=%.2f, Final=%.2f", scaleX, scaleY, scaleFactor);
+                
                 return @{
                     @"displayID": @(displayID),
                     @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
-                    @"physicalSize": [NSValue valueWithSize:NSMakeSize(physicalSize.width, physicalSize.height)],
+                    @"physicalSize": [NSValue valueWithSize:NSMakeSize(actualPhysicalSize.width, actualPhysicalSize.height)],
                     @"scaleFactor": @(scaleFactor),
                     @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
                 };
             }
         }
         
-        // Fallback to main display
+        // Fallback to main display with REAL physical dimensions
         CGDirectDisplayID mainDisplay = CGMainDisplayID();
         CGRect displayBounds = CGDisplayBounds(mainDisplay);
+        
+        // Get REAL physical dimensions using multiple detection methods
+        CGImageRef testImage = CGDisplayCreateImage(mainDisplay);
+        CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+        CGImageRelease(testImage);
+        
+        // Try display mode detection for true native resolution
+        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 physicalSize = CGSizeMake(CGDisplayPixelsWide(mainDisplay), CGDisplayPixelsHigh(mainDisplay));
+        CGFloat scaleFactor = MAX(actualPhysicalSize.width / logicalSize.width, actualPhysicalSize.height / logicalSize.height);
         
         return @{
             @"displayID": @(mainDisplay),
             @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
-            @"physicalSize": [NSValue valueWithSize:NSMakeSize(physicalSize.width, physicalSize.height)],
-            @"scaleFactor": @(MAX(physicalSize.width / logicalSize.width, physicalSize.height / logicalSize.height)),
+            @"physicalSize": [NSValue valueWithSize:NSMakeSize(actualPhysicalSize.width, actualPhysicalSize.height)],
+            @"scaleFactor": @(scaleFactor),
             @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
         };
     } @catch (NSException *exception) {
@@ -549,21 +619,9 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
             NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
             
-            // CRITICAL FIX: Convert physical coordinates to logical coordinates
-            // CGEventGetLocation returns physical coordinates on Retina displays
-            if (scaleFactor > 1.1) {
-                // Convert to display-relative, then scale down to logical, then back to global logical
-                CGFloat displayRelativeX = rawLocation.x - displayBounds.origin.x;
-                CGFloat displayRelativeY = rawLocation.y - displayBounds.origin.y;
-                
-                // Scale down to logical coordinates
-                CGFloat logicalRelativeX = displayRelativeX / scaleFactor;
-                CGFloat logicalRelativeY = displayRelativeY / scaleFactor;
-                
-                // Convert back to global logical coordinates
-                logicalLocation.x = displayBounds.origin.x + logicalRelativeX;
-                logicalLocation.y = displayBounds.origin.y + logicalRelativeY;
-            }
+            // CGEventGetLocation returns LOGICAL coordinates (correct for JS layer)
+            // Keep logical coordinates - transformation happens in JS layer
+            logicalLocation = rawLocation;
         }
         
         NSString *cursorType = getCursorType();
@@ -602,12 +660,27 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
         result.Set("cursorType", Napi::String::New(env, [cursorType UTF8String]));
         result.Set("eventType", Napi::String::New(env, [eventType UTF8String]));
         
-        // Add scaling debug info
+        // Add scaling info for coordinate transformation
         if (scalingInfo) {
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
+            NSSize logicalSize = [[scalingInfo objectForKey:@"logicalSize"] sizeValue];
+            NSSize physicalSize = [[scalingInfo objectForKey:@"physicalSize"] sizeValue];
+            NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
+            
             result.Set("scaleFactor", Napi::Number::New(env, scaleFactor));
             result.Set("rawX", Napi::Number::New(env, (int)rawLocation.x));
             result.Set("rawY", Napi::Number::New(env, (int)rawLocation.y));
+            
+            // Add display dimension info for JS coordinate transformation
+            Napi::Object displayInfo = Napi::Object::New(env);
+            displayInfo.Set("logicalWidth", Napi::Number::New(env, logicalSize.width));
+            displayInfo.Set("logicalHeight", Napi::Number::New(env, logicalSize.height));
+            displayInfo.Set("physicalWidth", Napi::Number::New(env, physicalSize.width));
+            displayInfo.Set("physicalHeight", Napi::Number::New(env, physicalSize.height));
+            displayInfo.Set("displayX", Napi::Number::New(env, displayBounds.origin.x));
+            displayInfo.Set("displayY", Napi::Number::New(env, displayBounds.origin.y));
+            
+            result.Set("displayInfo", displayInfo);
         }
         
         return result;