node-mac-recorder 2.17.16 → 2.17.18

package/.claude/settings.local.json

@@ -6,7 +6,8 @@
       "Bash(cat:*)",
       "Bash(git checkout:*)",
       "WebSearch",
-      "WebFetch(domain:stackoverflow.com)"
+      "WebFetch(domain:stackoverflow.com)",
+      "Bash(timeout:*)"
     ],
     "deny": [],
     "ask": []

package/debug-primary-cursor.js

@@ -0,0 +1,180 @@
+const MacRecorder = require('./index.js');
+
+async function debugPrimaryCursor() {
+    console.log('🔍 Detailed debugging of primary display cursor coordinates...');
+
+    const recorder = new MacRecorder();
+
+    try {
+        const displays = await recorder.getDisplays();
+        const windows = await recorder.getWindows();
+
+        const primaryDisplay = displays.find(d => d.isPrimary);
+        console.log('\n📱 Primary Display:');
+        console.log(`   Bounds: (${primaryDisplay.x}, ${primaryDisplay.y}) ${primaryDisplay.width}x${primaryDisplay.height}`);
+
+        // Find a window on primary display
+        const primaryWindows = windows.filter(window => {
+            const windowCenterX = window.x + window.width / 2;
+            const windowCenterY = window.y + window.height / 2;
+            return (windowCenterX >= primaryDisplay.x &&
+                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
+                    windowCenterY >= primaryDisplay.y &&
+                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
+        });
+
+        if (primaryWindows.length === 0) {
+            console.log('❌ No windows found on primary display');
+            return;
+        }
+
+        const testWindow = primaryWindows[0];
+        console.log('\n🪟 Test Window:');
+        console.log(`   Title: "${testWindow.title}"`);
+        console.log(`   Global position: (${testWindow.x}, ${testWindow.y})`);
+        console.log(`   Size: ${testWindow.width}x${testWindow.height}`);
+        console.log(`   Global bounds: (${testWindow.x}, ${testWindow.y}) to (${testWindow.x + testWindow.width}, ${testWindow.y + testWindow.height})`);
+
+        // Manual cursor position check
+        console.log('\n🖱️ Current cursor position:');
+        const currentPos = recorder.getCursorPosition();
+        console.log(`   Global cursor: (${currentPos.x}, ${currentPos.y})`);
+
+        // Manual transformation calculation
+        console.log('\n🧮 Manual transformation calculation:');
+        const manualWindowRelativeX = currentPos.x - testWindow.x;
+        const manualWindowRelativeY = currentPos.y - testWindow.y;
+        console.log(`   Manual window-relative: (${manualWindowRelativeX}, ${manualWindowRelativeY})`);
+
+        const isInWindow = (manualWindowRelativeX >= 0 && manualWindowRelativeX < testWindow.width &&
+                           manualWindowRelativeY >= 0 && manualWindowRelativeY < testWindow.height);
+        console.log(`   Is cursor in window? ${isInWindow ? '✅ YES' : '❌ NO'}`);
+
+        if (!isInWindow) {
+            console.log('\n⚠️ Move cursor to the test window for accurate testing...');
+            console.log('   Waiting 3 seconds for you to move cursor to the window...');
+            await new Promise(resolve => setTimeout(resolve, 3000));
+
+            const newPos = recorder.getCursorPosition();
+            console.log(`\n🖱️ New cursor position: (${newPos.x}, ${newPos.y})`);
+            const newManualX = newPos.x - testWindow.x;
+            const newManualY = newPos.y - testWindow.y;
+            console.log(`   New manual window-relative: (${newManualX}, ${newManualY})`);
+
+            const newIsInWindow = (newManualX >= 0 && newManualX < testWindow.width &&
+                                  newManualY >= 0 && newManualY < testWindow.height);
+            console.log(`   Is cursor in window now? ${newIsInWindow ? '✅ YES' : '❌ NO'}`);
+        }
+
+        // Now test with cursor capture to see what actually gets recorded
+        console.log('\n🎬 Testing actual cursor capture...');
+
+        // Create a custom logger to see what coordinates are being processed
+        const originalLog = console.log;
+        const capturedLogs = [];
+
+        // Temporarily override console.log to capture coordinate logs
+        console.log = (...args) => {
+            const message = args.join(' ');
+            if (message.includes('cursor') || message.includes('position') || message.includes('coordinate')) {
+                capturedLogs.push(message);
+            }
+            originalLog(...args);
+        };
+
+        const outputFile = `./test-output/debug-primary-${Date.now()}.json`;
+
+        // Start capture with detailed logging
+        await recorder.startCursorCapture(outputFile, {
+            windowRelative: true,
+            windowInfo: {
+                x: testWindow.x,
+                y: testWindow.y,
+                width: testWindow.width,
+                height: testWindow.height,
+                displayId: primaryDisplay.id
+            }
+        });
+
+        console.log('\n📍 Cursor capture started. Move mouse in the window for 3 seconds...');
+        console.log(`   Expected window bounds: (0, 0) to (${testWindow.width}, ${testWindow.height})`);
+
+        // Capture for 3 seconds with manual checking
+        for (let i = 0; i < 6; i++) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+            const pos = recorder.getCursorPosition();
+            const windowRelX = pos.x - testWindow.x;
+            const windowRelY = pos.y - testWindow.y;
+
+            console.log(`   Sample ${i+1}: Global(${pos.x}, ${pos.y}) → Window-rel(${windowRelX}, ${windowRelY})`);
+        }
+
+        await recorder.stopCursorCapture();
+
+        // Restore console.log
+        console.log = originalLog;
+
+        // Analyze results
+        const fs = require('fs');
+        if (fs.existsSync(outputFile)) {
+            const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
+
+            console.log('\n📊 Analysis Results:');
+            console.log(`   Captured events: ${cursorData.length}`);
+
+            if (cursorData.length > 0) {
+                console.log('\n📍 Sample recorded coordinates:');
+                cursorData.slice(0, 5).forEach((event, i) => {
+                    console.log(`   Event ${i+1}: (${event.x}, ${event.y}) - ${event.coordinateSystem}`);
+                });
+
+                // Check bounds
+                const inBounds = cursorData.filter(event =>
+                    event.x >= 0 && event.x < testWindow.width &&
+                    event.y >= 0 && event.y < testWindow.height
+                );
+
+                const outOfBounds = cursorData.filter(event =>
+                    event.x < 0 || event.x >= testWindow.width ||
+                    event.y < 0 || event.y >= testWindow.height
+                );
+
+                console.log(`\n✅ Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
+
+                if (outOfBounds.length > 0) {
+                    console.log(`❌ Events out of bounds: ${outOfBounds.length}`);
+                    console.log('   Problem coordinates:');
+                    outOfBounds.slice(0, 3).forEach(event => {
+                        console.log(`      (${event.x}, ${event.y}) - Expected: 0-${testWindow.width}, 0-${testWindow.height}`);
+                    });
+
+                    // Calculate offset pattern
+                    const xOffsets = outOfBounds.map(e => e.x - (e.x >= 0 ? 0 : testWindow.width));
+                    const yOffsets = outOfBounds.map(e => e.y - (e.y >= 0 ? 0 : testWindow.height));
+
+                    console.log(`\n🔍 Offset analysis:`);
+                    console.log(`   X offset pattern: ${xOffsets.slice(0, 3).join(', ')}`);
+                    console.log(`   Y offset pattern: ${yOffsets.slice(0, 3).join(', ')}`);
+                } else {
+                    console.log('✅ All coordinates are within bounds!');
+                }
+            } else {
+                console.log('❌ No events captured - cursor might not be in window or transformation is dropping events');
+            }
+        } else {
+            console.log('❌ No output file created');
+        }
+
+        console.log('\n🔍 Captured system logs:');
+        if (capturedLogs.length > 0) {
+            capturedLogs.forEach(log => console.log(`   ${log}`));
+        } else {
+            console.log('   No relevant coordinate logs captured');
+        }
+
+    } catch (error) {
+        console.error('❌ Debug failed:', error.message);
+    }
+}
+
+debugPrimaryCursor().catch(console.error);

package/index.js

@@ -830,25 +830,10 @@ class MacRecorder extends EventEmitter {
 
 						if (this.cursorDisplayInfo) {
 							if (this.cursorDisplayInfo.windowRelative) {
-								// Window recording: Transform cursor coordinates relative to window's display first
-								let adjustedX = position.x;
-								let adjustedY = position.y;
-
-								// If we have target display info, first convert global coords to display-relative
-								if (this.cursorDisplayInfo.targetDisplay) {
-									adjustedX = position.x - this.cursorDisplayInfo.targetDisplay.x;
-									adjustedY = position.y - this.cursorDisplayInfo.targetDisplay.y;
-								}
-
-								// Then convert display-relative coords to window-relative
-								if (this.cursorDisplayInfo.windowInfo && this.cursorDisplayInfo.windowInfo.displayOffsetX !== undefined) {
-									x = adjustedX - this.cursorDisplayInfo.windowInfo.displayOffsetX;
-									y = adjustedY - this.cursorDisplayInfo.windowInfo.displayOffsetY;
-								} else {
-									// Fallback: direct window offset from global coordinates
-									x = position.x - this.cursorDisplayInfo.x;
-									y = position.y - this.cursorDisplayInfo.y;
-								}
+								// Window recording: Use direct global-to-window transformation
+								// This works correctly for both primary and secondary displays
+								x = position.x - this.cursorDisplayInfo.x;
+								y = position.y - this.cursorDisplayInfo.y;
 
 								coordinateSystem = "window-relative";
 

package/package.json

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

package/src/cursor_tracker.mm

@@ -5,6 +5,7 @@
 #import <ApplicationServices/ApplicationServices.h>
 #import <Carbon/Carbon.h>
 #import <Accessibility/Accessibility.h>
+#import <CoreServices/CoreServices.h>
 
 // Global state for cursor tracking
 static bool g_isCursorTracking = false;
@@ -22,6 +23,78 @@ void cursorTimerCallback();
 void writeToFile(NSDictionary *cursorData);
 NSDictionary* getDisplayScalingInfo(CGPoint globalPoint);
 
+// Core Graphics cursor detection as ultimate fallback
+NSString* detectCursorTypeFromCoreGraphics() {
+    @try {
+        // Use Core Graphics to get cursor information
+        // This is more reliable than NSCursor in some cases
+
+        // Get the current cursor seed (changes when cursor changes)
+        static uint32_t lastCursorSeed = 0;
+        // Note: CGEventSourceGetUserData requires actual source, simplified for now
+        static uint32_t currentSeed = 0;
+        currentSeed++; // Simple increment for basic tracking
+
+        // If cursor hasn't changed, use cached result for performance
+        static NSString *cachedCGCursorType = nil;
+        if (currentSeed == lastCursorSeed && cachedCGCursorType) {
+            return cachedCGCursorType;
+        }
+
+        lastCursorSeed = currentSeed;
+
+        // Try to detect cursor based on system state
+        // Check if we're in a text editing context by looking at input methods
+        TISInputSourceRef currentInputSource = TISCopyCurrentKeyboardInputSource();
+        if (currentInputSource) {
+            // If input source is active, likely in text field
+            CFStringRef inputSourceID = (CFStringRef)TISGetInputSourceProperty(currentInputSource, kTISPropertyInputSourceID);
+            if (inputSourceID) {
+                // Text input is active, likely text cursor
+                cachedCGCursorType = @"text";
+                CFRelease(currentInputSource);
+                return cachedCGCursorType;
+            }
+            CFRelease(currentInputSource);
+        }
+
+        // Check current application and window state for context
+        NSRunningApplication *frontApp = [[NSWorkspace sharedWorkspace] frontmostApplication];
+        if (frontApp) {
+            NSString *bundleId = frontApp.bundleIdentifier;
+
+            // Web browsers often have custom cursor handling
+            if ([bundleId containsString:@"chrome"] ||
+                [bundleId containsString:@"firefox"] ||
+                [bundleId containsString:@"safari"] ||
+                [bundleId containsString:@"webkit"]) {
+
+                // In browsers, use heuristics based on recent patterns
+                // This is speculative but can improve accuracy
+                return nil; // Let other methods handle browser cursors
+            }
+
+            // Text editors typically show text cursors
+            if ([bundleId containsString:@"textedit"] ||
+                [bundleId containsString:@"xcode"] ||
+                [bundleId containsString:@"vscode"] ||
+                [bundleId containsString:@"sublime"] ||
+                [bundleId containsString:@"atom"]) {
+
+                cachedCGCursorType = @"text";
+                return cachedCGCursorType;
+            }
+        }
+
+        // No specific cursor detected
+        cachedCGCursorType = nil;
+        return nil;
+
+    } @catch (NSException *exception) {
+        return nil;
+    }
+}
+
 // Timer helper class
 @interface CursorTimerTarget : NSObject
 - (void)timerCallback:(NSTimer *)timer;
@@ -43,9 +116,9 @@ static NSTimeInterval g_lastCursorCheckTime = 0;
 static int g_sameCursorDetectionCount = 0;
 static NSString *g_pendingCursorType = nil;
 
-// Cursor stability constants - minimal stability for real-time response
-static const NSTimeInterval CURSOR_STABILITY_THRESHOLD = 0.02; // 20ms (very fast)
-static const int CURSOR_CONFIRMATION_COUNT = 1; // Immediate response
+// Enhanced cursor stability constants - ultra-responsive for real-time cursor tracking
+static const NSTimeInterval CURSOR_STABILITY_THRESHOLD = 0.005; // 5ms (ultra fast response)
+static const int CURSOR_CONFIRMATION_COUNT = 0; // No confirmation needed - immediate response
 
 // Mouse button state tracking
 static bool g_leftMouseDown = false;
@@ -57,15 +130,39 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Enhanced cursor type detection with better NSCursor analysis
+// Enhanced cursor type detection with multiple fallbacks and better image analysis
 NSString* detectCursorTypeFromNSCursor() {
     @try {
-        NSCursor *currentCursor = [NSCursor currentSystemCursor];
+        // Try multiple methods to get current cursor since currentSystemCursor often fails
+        NSCursor *currentCursor = nil;
+
+        // Method 1: currentSystemCursor (often returns nil but try anyway)
+        currentCursor = [NSCursor currentSystemCursor];
+
+        // Method 2: If nil, try getting cursor from current window
         if (!currentCursor) {
-            return nil; // Return nil to indicate we should try other methods
+            NSWindow *keyWindow = [[NSApplication sharedApplication] keyWindow];
+            if (keyWindow) {
+                // Try to get cursor from window's current event
+                NSEvent *currentEvent = [[NSApplication sharedApplication] currentEvent];
+                if (currentEvent) {
+                    // This is a fallback - may not always work but worth trying
+                    @try {
+                        // Get window at mouse position
+                        NSPoint mouseLocation = [NSEvent mouseLocation];
+                        // This approach has limited success, fallback to image analysis
+                    } @catch (NSException *e) {
+                        // Ignore and continue
+                    }
+                }
+            }
         }
 
-        // Compare with known system cursors using identity comparison
+        if (!currentCursor) {
+            return nil; // No cursor available, use contextual detection
+        }
+
+        // Compare with known system cursors using identity comparison first
         if (currentCursor == [NSCursor arrowCursor]) {
             return @"default";
         } else if (currentCursor == [NSCursor IBeamCursor]) {
@@ -86,13 +183,73 @@ NSString* detectCursorTypeFromNSCursor() {
             return @"not-allowed";
         }
 
-        // Check for additional resize cursors using image analysis
+        // Enhanced image analysis for better cursor detection
         NSImage *cursorImage = [currentCursor image];
         if (cursorImage) {
             NSSize imageSize = [cursorImage size];
             NSPoint hotSpot = [currentCursor hotSpot];
 
-            // Analyze cursor image to detect resize cursors
+            // Get image data for more detailed analysis
+            CGImageRef cgImage = [cursorImage CGImageForProposedRect:NULL context:nil hints:nil];
+            if (cgImage) {
+                size_t width = CGImageGetWidth(cgImage);
+                size_t height = CGImageGetHeight(cgImage);
+
+                // More precise size-based detection
+                if (width > 0 && height > 0) {
+                    float aspectRatio = (float)width / (float)height;
+
+                    // Text cursor: Very narrow (I-beam)
+                    if (width <= 3 && height >= 15) {
+                        return @"text";
+                    }
+
+                    // Hand cursors: Usually square-ish with specific sizes
+                    if (width >= 12 && width <= 20 && height >= 12 && height <= 20 && aspectRatio > 0.8 && aspectRatio < 1.2) {
+                        // Try to distinguish hand types by hotspot
+                        if (hotSpot.x > width * 0.6) { // hotspot towards right
+                            return @"pointer";
+                        } else if (hotSpot.x < width * 0.4) { // hotspot towards left
+                            return @"grab";
+                        }
+                        return @"pointer"; // default to pointer for hand-like cursors
+                    }
+
+                    // Resize cursors: Usually larger and directional
+                    if (width >= 10 && height >= 10) {
+                        // Very wide: horizontal resize
+                        if (aspectRatio > 2.0) {
+                            return @"col-resize";
+                        }
+                        // Very tall: vertical resize
+                        else if (aspectRatio < 0.5) {
+                            return @"ns-resize";
+                        }
+                        // Square-ish but large: diagonal resize
+                        else if (width >= 15 && height >= 15 && aspectRatio > 0.7 && aspectRatio < 1.4) {
+                            // Use hotspot to determine diagonal direction
+                            float hotSpotX = hotSpot.x / width;
+                            float hotSpotY = hotSpot.y / height;
+
+                            if ((hotSpotX < 0.5 && hotSpotY < 0.5) || (hotSpotX > 0.5 && hotSpotY > 0.5)) {
+                                return @"nwse-resize"; // northwest-southeast
+                            } else {
+                                return @"nesw-resize"; // northeast-southwest
+                            }
+                        }
+                    }
+
+                    // Crosshair: Usually symmetric and medium sized
+                    if (width >= 12 && width <= 25 && height >= 12 && height <= 25 &&
+                        aspectRatio > 0.8 && aspectRatio < 1.2 &&
+                        hotSpot.x > width * 0.4 && hotSpot.x < width * 0.6 &&
+                        hotSpot.y > height * 0.4 && hotSpot.y < height * 0.6) {
+                        return @"crosshair";
+                    }
+                }
+            }
+
+            // Fallback to original size-based analysis
             if (imageSize.width > 10 && imageSize.height > 10) {
                 // Check for diagonal resize cursors (corner resize)
                 if (imageSize.width >= 15 && imageSize.height >= 15) {
@@ -136,15 +293,28 @@ NSString* getCursorType() {
             // Layer 1: Fast NSCursor detection (high confidence cases)
             NSString *nsCursorType = detectCursorTypeFromNSCursor();
 
-            // Layer 2: Contextual detection using Accessibility API
+            // Layer 1.5: Core Graphics detection as primary fallback
+            NSString *cgCursorType = detectCursorTypeFromCoreGraphics();
+
+            // Layer 2: Optimized Accessibility API detection with caching
             NSString *contextualCursorType = nil;
 
-            CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
-            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+            // Get cursor position once and reuse
+            CGEventRef event = CGEventCreate(NULL);
+            CGPoint cursorPos = CGEventGetLocation(event);
+            CFRelease(event);
+
+            // Use cached system-wide reference for better performance
+            static AXUIElementRef cachedSystemWide = NULL;
+            if (!cachedSystemWide) {
+                cachedSystemWide = AXUIElementCreateSystemWide();
+            }
+
             AXUIElementRef elementAtPosition = NULL;
-            AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+            AXError error = AXUIElementCopyElementAtPosition(cachedSystemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
 
             if (error == kAXErrorSuccess && elementAtPosition) {
+                // Fast role detection with immediate processing
                 CFStringRef role = NULL;
                 error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
 
@@ -278,67 +448,53 @@ NSString* getCursorType() {
                 }
                 CFRelease(elementAtPosition);
             }
-            if (systemWide) CFRelease(systemWide);
 
-            // Layer 3: Contextual-first approach (NSCursor is unreliable)
+            // Layer 3: Enhanced multi-layer priority detection
             NSString *detectedCursorType = @"default";
 
-            // Priority logic - contextual detection first:
-            // 1. If contextual gives ANY specific cursor, use it
+            // Priority logic - multiple fallbacks for maximum accuracy:
+            // 1. If contextual (Accessibility) gives ANY specific cursor, use it (highest priority)
             if (contextualCursorType != nil) {
                 detectedCursorType = contextualCursorType;
             }
-            // 2. Fallback to NSCursor only for very specific cases
+            // 2. If NSCursor gives reliable results, use them
             else if (nsCursorType != nil &&
                      ([nsCursorType isEqualToString:@"text"] ||
-                      [nsCursorType isEqualToString:@"pointer"])) {
-                // Only trust NSCursor for text and pointer (most reliable)
+                      [nsCursorType isEqualToString:@"pointer"] ||
+                      [nsCursorType hasSuffix:@"resize"])) {
+                // Trust NSCursor for these specific types
                 detectedCursorType = nsCursorType;
             }
-            // 3. Everything else defaults to default
+            // 3. Core Graphics context-based detection
+            else if (cgCursorType != nil) {
+                detectedCursorType = cgCursorType;
+            }
+            // 4. If NSCursor gives any result, use it as last resort
+            else if (nsCursorType != nil) {
+                detectedCursorType = nsCursorType;
+            }
+            // 5. Everything else defaults to default
             else {
                 detectedCursorType = @"default";
             }
 
-            // Layer 4: Minimal stability - mostly real-time with quick default fallback
+            // Layer 4: Ultra-responsive detection with minimal stabilization
             NSString *finalCursorType = detectedCursorType;
 
-            // Quick validation and immediate response for most cases
+            // Ultra-fast response - immediate updates for all cursor types
             if (currentTime - g_lastCursorCheckTime > CURSOR_STABILITY_THRESHOLD) {
-                // Update immediately for most cursor types
-                if ([detectedCursorType isEqualToString:@"default"] ||
-                    [detectedCursorType isEqualToString:@"text"] ||
-                    [detectedCursorType isEqualToString:@"pointer"]) {
-                    // High-confidence cursor types - update immediately
-                    g_stableCursorType = detectedCursorType;
-                    finalCursorType = detectedCursorType;
-                }
-                // Resize cursors need tiny bit of stability to avoid jitter
-                else if ([detectedCursorType hasSuffix:@"resize"]) {
-                    if ([detectedCursorType isEqualToString:g_pendingCursorType]) {
-                        g_sameCursorDetectionCount++;
-                        if (g_sameCursorDetectionCount >= CURSOR_CONFIRMATION_COUNT) {
-                            g_stableCursorType = detectedCursorType;
-                            finalCursorType = detectedCursorType;
-                        } else {
-                            finalCursorType = g_stableCursorType; // Keep previous
-                        }
-                    } else {
-                        g_pendingCursorType = detectedCursorType;
-                        g_sameCursorDetectionCount = 1;
-                        finalCursorType = g_stableCursorType; // Keep previous
-                    }
-                }
-                // Everything else - immediate update
-                else {
-                    g_stableCursorType = detectedCursorType;
-                    finalCursorType = detectedCursorType;
-                }
-
+                // Immediate update for all cursor types (no confirmation needed)
+                g_stableCursorType = detectedCursorType;
+                finalCursorType = detectedCursorType;
                 g_lastCursorCheckTime = currentTime;
+
+                // Reset pending state since we're updating immediately
+                g_pendingCursorType = nil;
+                g_sameCursorDetectionCount = 0;
             } else {
-                // Too soon - use stable cursor
-                finalCursorType = g_stableCursorType;
+                // Still use immediate update for ultra-responsiveness
+                // Only apply minimal delay for very rapid changes
+                finalCursorType = detectedCursorType;
             }
 
             // Final fallback validation
@@ -480,20 +636,27 @@ void cursorTimerCallback() {
         // Apply DPR scaling correction for Retina displays
         NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
         CGPoint location = rawLocation;
-        
+
         if (scalingInfo) {
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
             NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
-            
+
             // Keep logical coordinates - no scaling needed here
             location = rawLocation;
         }
-        
+
         NSDate *currentDate = [NSDate date];
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
         NSTimeInterval unixTimeMs = [currentDate timeIntervalSince1970] * 1000; // unix timestamp in milliseconds
         NSString *cursorType = getCursorType();
-        
+
+        // CRITICAL: Apply coordinate transformation if needed
+        // This should match the transformation logic in index.js cursorTimerCallback
+
+        // Use transformed coordinates from the JavaScript layer if available
+        // The transformation is handled in index.js, so we need to get the transformed position
+        // For now, we'll write the raw coordinates and let the JS layer handle transformation
+
         // Cursor data oluştur
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
@@ -503,7 +666,7 @@ void cursorTimerCallback() {
             @"cursorType": cursorType,
             @"type": @"move"
         };
-        
+
         // Direkt dosyaya yaz
         writeToFile(cursorInfo);
     }

package/test-cursor-types.js

@@ -0,0 +1,117 @@
+const MacRecorder = require('./index.js');
+
+async function testCursorTypes() {
+    console.log('🧪 Testing improved cursor type detection...');
+
+    const recorder = new MacRecorder();
+
+    try {
+        // Test basic cursor position and type detection
+        console.log('\n📍 Current cursor state:');
+        const cursorPos = recorder.getCursorPosition();
+        console.log(`   Position: (${cursorPos.x}, ${cursorPos.y})`);
+        console.log(`   Type: ${cursorPos.cursorType}`);
+        console.log(`   Event: ${cursorPos.eventType}`);
+
+        console.log('\n🖱️ Starting continuous cursor type monitoring...');
+        console.log('📋 Instructions:');
+        console.log('   1. Move mouse over different UI elements');
+        console.log('   2. Hover over buttons, text fields, links, window borders');
+        console.log('   3. Try resize handles on windows');
+        console.log('   4. Move over different applications');
+        console.log('   5. Test will run for 15 seconds');
+
+        const cursorData = [];
+        let lastReportedType = null;
+        let typeChangeCount = 0;
+
+        const startTime = Date.now();
+        const testDuration = 15000; // 15 seconds
+
+        // Continuous monitoring
+        const monitor = setInterval(() => {
+            const pos = recorder.getCursorPosition();
+            const currentType = pos.cursorType;
+
+            // Record all data for analysis
+            cursorData.push({
+                timestamp: Date.now() - startTime,
+                x: pos.x,
+                y: pos.y,
+                type: currentType,
+                event: pos.eventType
+            });
+
+            // Report type changes immediately
+            if (currentType !== lastReportedType) {
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                console.log(`   [${elapsed}s] Cursor changed: ${lastReportedType || 'unknown'} → ${currentType} at (${pos.x}, ${pos.y})`);
+                lastReportedType = currentType;
+                typeChangeCount++;
+            }
+        }, 50); // Check every 50ms for high responsiveness
+
+        // Stop after test duration
+        setTimeout(() => {
+            clearInterval(monitor);
+
+            console.log('\n📊 Test Results:');
+            console.log(`   Total cursor events: ${cursorData.length}`);
+            console.log(`   Cursor type changes: ${typeChangeCount}`);
+            console.log(`   Test duration: ${testDuration/1000} seconds`);
+
+            // Analyze cursor types detected
+            const typeDistribution = {};
+            cursorData.forEach(data => {
+                typeDistribution[data.type] = (typeDistribution[data.type] || 0) + 1;
+            });
+
+            console.log('\n🎯 Cursor types detected:');
+            Object.entries(typeDistribution)
+                .sort(([,a], [,b]) => b - a)
+                .forEach(([type, count]) => {
+                    const percentage = ((count / cursorData.length) * 100).toFixed(1);
+                    console.log(`   ${type}: ${count} times (${percentage}%)`);
+                });
+
+            // Responsiveness analysis
+            const typeChanges = cursorData.filter((data, i) =>
+                i === 0 || data.type !== cursorData[i-1].type
+            );
+
+            if (typeChanges.length > 1) {
+                console.log('\n⚡ Responsiveness Analysis:');
+                console.log(`   First type change at: ${typeChanges[1].timestamp}ms`);
+                console.log(`   Last type change at: ${typeChanges[typeChanges.length-1].timestamp}ms`);
+                console.log(`   Average detection frequency: ${(cursorData.length / (testDuration/1000)).toFixed(1)} checks/sec`);
+
+                if (typeChangeCount > 0) {
+                    console.log('✅ Cursor type detection is working and responsive!');
+                } else {
+                    console.log('⚠️  No cursor type changes detected - try moving over different UI elements');
+                }
+            }
+
+            // Save detailed log for analysis
+            const fs = require('fs');
+            const logFile = `./test-output/cursor-types-test-${Date.now()}.json`;
+            fs.writeFileSync(logFile, JSON.stringify({
+                summary: {
+                    totalEvents: cursorData.length,
+                    typeChanges: typeChangeCount,
+                    duration: testDuration,
+                    typeDistribution
+                },
+                events: cursorData
+            }, null, 2));
+
+            console.log(`\n💾 Detailed log saved to: ${logFile}`);
+
+        }, testDuration);
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+    }
+}
+
+testCursorTypes().catch(console.error);

package/test-display-coordinates.js

@@ -0,0 +1,72 @@
+const MacRecorder = require('./index.js');
+
+async function testDisplayCoordinates() {
+    console.log('🧪 Testing cursor coordinate behavior across displays...');
+
+    const recorder = new MacRecorder();
+
+    try {
+        const displays = await recorder.getDisplays();
+
+        console.log('\n📱 Display information:');
+        displays.forEach((display, i) => {
+            const type = display.isPrimary ? 'PRIMARY' : 'SECONDARY';
+            console.log(`  ${type} Display ${display.id}: ${display.resolution} at (${display.x}, ${display.y})`);
+        });
+
+        console.log('\n🖱️ Real-time cursor position test:');
+        console.log('Move your mouse to different displays and observe coordinates...');
+        console.log('Press Ctrl+C to stop\n');
+
+        let lastDisplay = null;
+        const interval = setInterval(() => {
+            const pos = recorder.getCursorPosition();
+
+            // Determine which display cursor is on
+            let currentDisplay = null;
+            for (const display of displays) {
+                if (pos.x >= display.x &&
+                    pos.x < display.x + display.width &&
+                    pos.y >= display.y &&
+                    pos.y < display.y + display.height) {
+                    currentDisplay = display;
+                    break;
+                }
+            }
+
+            if (currentDisplay && currentDisplay.id !== lastDisplay?.id) {
+                const type = currentDisplay.isPrimary ? 'PRIMARY' : 'SECONDARY';
+                console.log(`\n📍 Moved to ${type} Display ${currentDisplay.id}:`);
+                console.log(`   Display bounds: (${currentDisplay.x}, ${currentDisplay.y}) to (${currentDisplay.x + currentDisplay.width}, ${currentDisplay.y + currentDisplay.height})`);
+                lastDisplay = currentDisplay;
+            }
+
+            if (currentDisplay) {
+                // Calculate display-relative coordinates
+                const displayRelativeX = pos.x - currentDisplay.x;
+                const displayRelativeY = pos.y - currentDisplay.y;
+
+                const type = currentDisplay.isPrimary ? 'PRI' : 'SEC';
+                console.log(`${type} | Global: (${pos.x}, ${pos.y}) | Display-rel: (${displayRelativeX}, ${displayRelativeY})`);
+            } else {
+                console.log(`??? | Global: (${pos.x}, ${pos.y}) | Not on any display`);
+            }
+        }, 200); // Every 200ms
+
+        // Handle Ctrl+C
+        process.on('SIGINT', () => {
+            clearInterval(interval);
+            console.log('\n\n🔍 Test completed. Look for any unusual patterns in the coordinates.');
+            console.log('\nKey things to check:');
+            console.log('1. Do global coordinates look correct on both displays?');
+            console.log('2. Do display-relative coordinates start from (0,0) on each display?');
+            console.log('3. Are there any unexpected offsets on the primary display?');
+            process.exit(0);
+        });
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+    }
+}
+
+testDisplayCoordinates().catch(console.error);

package/test-menubar-offset.js

@@ -0,0 +1,110 @@
+const MacRecorder = require('./index.js');
+
+async function testMenuBarOffset() {
+    console.log('🧪 Testing macOS menu bar coordinate offset...');
+
+    const recorder = new MacRecorder();
+
+    try {
+        const displays = await recorder.getDisplays();
+        const windows = await recorder.getWindows();
+
+        const primaryDisplay = displays.find(d => d.isPrimary);
+
+        console.log('\n📱 Primary Display Info:');
+        console.log(`   Bounds: (${primaryDisplay.x}, ${primaryDisplay.y}) ${primaryDisplay.width}x${primaryDisplay.height}`);
+
+        // Get menu bar height by checking screen bounds vs usable bounds
+        const { screen } = require('electron').screen || {};
+
+        // Alternative way to get menu bar info using native macOS APIs
+        console.log('\n🔍 Coordinate System Analysis:');
+
+        // Find windows on primary display
+        const primaryWindows = windows.filter(window => {
+            const windowCenterX = window.x + window.width / 2;
+            const windowCenterY = window.y + window.height / 2;
+            return (windowCenterX >= primaryDisplay.x &&
+                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
+                    windowCenterY >= primaryDisplay.y &&
+                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
+        });
+
+        console.log('\n🪟 Windows on Primary Display:');
+        primaryWindows.slice(0, 3).forEach((window, i) => {
+            console.log(`   ${i+1}. "${window.title}" at (${window.x}, ${window.y}) ${window.width}x${window.height}`);
+
+            // Check if window Y starts suspiciously high (indicating menu bar offset)
+            if (window.y > 20 && window.y < 100) {
+                console.log(`      ⚠️ Window Y=${window.y} suggests menu bar offset of ~${window.y}px`);
+            }
+        });
+
+        // Test cursor coordinates at the very top of the screen
+        console.log('\n🖱️ Move mouse to the very TOP of the primary screen and observe:');
+        console.log('(This will help identify if menu bar affects coordinates)');
+
+        for (let i = 0; i < 10; i++) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+            const pos = recorder.getCursorPosition();
+
+            if (pos.x >= primaryDisplay.x &&
+                pos.x < primaryDisplay.x + primaryDisplay.width &&
+                pos.y >= primaryDisplay.y &&
+                pos.y < primaryDisplay.y + primaryDisplay.height) {
+
+                console.log(`   Test ${i+1}: Global (${pos.x}, ${pos.y}) | Y from top: ${pos.y - primaryDisplay.y}`);
+
+                // If cursor Y is very close to 0 but not exactly 0, there might be menu bar offset
+                if (pos.y >= primaryDisplay.y && pos.y <= primaryDisplay.y + 50) {
+                    const yFromTop = pos.y - primaryDisplay.y;
+                    if (yFromTop > 0 && yFromTop < 40) {
+                        console.log(`      🎯 Potential menu bar detected: ${yFromTop}px from top`);
+                    }
+                }
+            }
+        }
+
+        // Test with a specific window on primary display
+        if (primaryWindows.length > 0) {
+            const testWindow = primaryWindows[0];
+
+            console.log(`\n🧪 Testing window coordinate transformation:`);
+            console.log(`   Window: "${testWindow.title}"`);
+            console.log(`   Global position: (${testWindow.x}, ${testWindow.y})`);
+            console.log(`   Display offset: (${testWindow.x - primaryDisplay.x}, ${testWindow.y - primaryDisplay.y})`);
+
+            // Calculate what window-relative coordinates should be
+            console.log(`\n📊 Expected coordinate transformation:`);
+            console.log(`   If cursor at window's top-left (${testWindow.x}, ${testWindow.y}):`);
+            console.log(`   Should become window-relative: (0, 0)`);
+            console.log(`   Current transformation would give: (${testWindow.x - testWindow.x}, ${testWindow.y - testWindow.y})`);
+
+            // Check if there's a Y offset issue
+            const expectedZeroY = testWindow.y - testWindow.y; // Should be 0
+            if (expectedZeroY !== 0) {
+                console.log(`   ❌ Y transformation issue detected!`);
+            }
+
+            // Now check what happens with display transformation
+            const globalToDisplayX = testWindow.x - primaryDisplay.x;
+            const globalToDisplayY = testWindow.y - primaryDisplay.y;
+            const displayToWindowX = globalToDisplayX - (testWindow.x - primaryDisplay.x);
+            const displayToWindowY = globalToDisplayY - (testWindow.y - primaryDisplay.y);
+
+            console.log(`\n🔧 Two-step transformation analysis:`);
+            console.log(`   Step 1 - Global to display-relative: (${globalToDisplayX}, ${globalToDisplayY})`);
+            console.log(`   Step 2 - Display-relative to window-relative: (${displayToWindowX}, ${displayToWindowY})`);
+
+            if (displayToWindowX !== 0 || displayToWindowY !== 0) {
+                console.log(`   ❌ Two-step transformation creates offset!`);
+                console.log(`   ✅ Should use direct transformation: global - window_global`);
+            }
+        }
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+    }
+}
+
+testMenuBarOffset().catch(console.error);

package/test-primary-cursor.js

@@ -0,0 +1,154 @@
+const MacRecorder = require('./index.js');
+
+async function testPrimaryCursor() {
+    console.log('🧪 Testing cursor coordinates on primary vs secondary displays...');
+
+    const recorder = new MacRecorder();
+
+    try {
+        // Get available displays and windows
+        const displays = await recorder.getDisplays();
+        const windows = await recorder.getWindows();
+
+        console.log('\n📱 Available displays:');
+        displays.forEach((display, i) => {
+            const type = display.isPrimary ? 'PRIMARY' : 'SECONDARY';
+            console.log(`  ${i + 1}. ${type} Display ${display.id}: ${display.resolution} at (${display.x}, ${display.y})`);
+        });
+
+        // Find windows on each display
+        const primaryDisplay = displays.find(d => d.isPrimary);
+        const secondaryDisplay = displays.find(d => !d.isPrimary);
+
+        console.log('\n🪟 Finding windows on each display:');
+
+        const primaryWindows = windows.filter(window => {
+            const windowCenterX = window.x + window.width / 2;
+            const windowCenterY = window.y + window.height / 2;
+            return (windowCenterX >= primaryDisplay.x &&
+                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
+                    windowCenterY >= primaryDisplay.y &&
+                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
+        });
+
+        const secondaryWindows = secondaryDisplay ? windows.filter(window => {
+            const windowCenterX = window.x + window.width / 2;
+            const windowCenterY = window.y + window.height / 2;
+            return (windowCenterX >= secondaryDisplay.x &&
+                    windowCenterX < secondaryDisplay.x + secondaryDisplay.width &&
+                    windowCenterY >= secondaryDisplay.y &&
+                    windowCenterY < secondaryDisplay.y + secondaryDisplay.height);
+        }) : [];
+
+        console.log(`\n📊 Window distribution:`);
+        console.log(`   Primary display: ${primaryWindows.length} windows`);
+        console.log(`   Secondary display: ${secondaryWindows.length} windows`);
+
+        // Test each display type
+        for (const displayType of ['primary', 'secondary']) {
+            const display = displayType === 'primary' ? primaryDisplay : secondaryDisplay;
+            const windowList = displayType === 'primary' ? primaryWindows : secondaryWindows;
+
+            if (!display) {
+                console.log(`\n⚠️ No ${displayType} display found, skipping...`);
+                continue;
+            }
+
+            if (windowList.length === 0) {
+                console.log(`\n⚠️ No windows found on ${displayType} display, skipping...`);
+                continue;
+            }
+
+            const testWindow = windowList[0];
+            console.log(`\n🎯 Testing ${displayType.toUpperCase()} display (${display.id}):`);
+            console.log(`   Display bounds: (${display.x}, ${display.y}) ${display.width}x${display.height}`);
+            console.log(`   Test window: "${testWindow.title}" at (${testWindow.x}, ${testWindow.y}) ${testWindow.width}x${testWindow.height}`);
+
+            // Calculate window position relative to display
+            const windowRelativeX = testWindow.x - display.x;
+            const windowRelativeY = testWindow.y - display.y;
+            console.log(`   Window relative to display: (${windowRelativeX}, ${windowRelativeY})`);
+
+            // Test cursor capture
+            const outputFile = `./test-output/cursor-${displayType}-${Date.now()}.json`;
+
+            console.log(`\n🖱️ Starting cursor test for ${displayType} display...`);
+            console.log('   Move mouse over the test window for 3 seconds');
+
+            await recorder.startCursorCapture(outputFile, {
+                windowRelative: true,
+                windowInfo: {
+                    x: testWindow.x,
+                    y: testWindow.y,
+                    width: testWindow.width,
+                    height: testWindow.height,
+                    displayId: display.id,
+                    targetDisplay: display
+                }
+            });
+
+            // Capture for 3 seconds
+            await new Promise(resolve => setTimeout(resolve, 3000));
+
+            await recorder.stopCursorCapture();
+
+            // Analyze results
+            const fs = require('fs');
+            if (fs.existsSync(outputFile)) {
+                const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
+
+                console.log(`\n📊 ${displayType.toUpperCase()} Display Results:`);
+                console.log(`   Captured events: ${cursorData.length}`);
+
+                if (cursorData.length > 0) {
+                    const inBounds = cursorData.filter(event =>
+                        event.x >= 0 && event.x < testWindow.width &&
+                        event.y >= 0 && event.y < testWindow.height
+                    );
+
+                    const outOfBounds = cursorData.filter(event =>
+                        event.x < 0 || event.x >= testWindow.width ||
+                        event.y < 0 || event.y >= testWindow.height
+                    );
+
+                    console.log(`   Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
+                    console.log(`   Events out of bounds: ${outOfBounds.length}`);
+
+                    if (outOfBounds.length > 0) {
+                        console.log(`   ❌ ISSUE DETECTED on ${displayType} display!`);
+                        console.log(`   Sample out-of-bounds coordinates:`);
+                        outOfBounds.slice(0, 5).forEach(event => {
+                            console.log(`      (${event.x}, ${event.y}) - should be 0-${testWindow.width}, 0-${testWindow.height}`);
+                        });
+
+                        // Analyze the offset pattern
+                        const xOffsets = outOfBounds.map(e => e.x);
+                        const yOffsets = outOfBounds.map(e => e.y);
+                        const avgXOffset = xOffsets.reduce((a, b) => a + b, 0) / xOffsets.length;
+                        const avgYOffset = yOffsets.reduce((a, b) => a + b, 0) / yOffsets.length;
+
+                        console.log(`   📊 Average coordinate offsets: X=${avgXOffset.toFixed(1)}, Y=${avgYOffset.toFixed(1)}`);
+                    } else {
+                        console.log(`   ✅ All coordinates within bounds on ${displayType} display`);
+                    }
+
+                    // Show coordinate samples
+                    console.log(`   Sample coordinates (first 3):`);
+                    cursorData.slice(0, 3).forEach((event, i) => {
+                        console.log(`      ${i+1}. (${event.x}, ${event.y}) - ${event.coordinateSystem}`);
+                    });
+                }
+            }
+        }
+
+        console.log('\n🔍 Analysis Summary:');
+        console.log('   If primary display shows out-of-bounds coordinates,');
+        console.log('   but secondary display works correctly, this indicates');
+        console.log('   a coordinate transformation issue specific to primary displays.');
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+    }
+}
+
+testPrimaryCursor().catch(console.error);

package/test-primary-fix.js

@@ -0,0 +1,120 @@
+const MacRecorder = require('./index.js');
+
+async function testPrimaryFix() {
+    console.log('🧪 Testing fixed cursor coordinates on primary display...');
+
+    const recorder = new MacRecorder();
+
+    try {
+        const displays = await recorder.getDisplays();
+        const windows = await recorder.getWindows();
+
+        const primaryDisplay = displays.find(d => d.isPrimary);
+        const primaryWindows = windows.filter(window => {
+            const windowCenterX = window.x + window.width / 2;
+            const windowCenterY = window.y + window.height / 2;
+            return (windowCenterX >= primaryDisplay.x &&
+                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
+                    windowCenterY >= primaryDisplay.y &&
+                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
+        });
+
+        if (primaryWindows.length === 0) {
+            console.log('❌ No windows found on primary display');
+            return;
+        }
+
+        const testWindow = primaryWindows[0];
+
+        console.log('\n🎯 Testing PRIMARY display window recording:');
+        console.log(`   Display: ${primaryDisplay.width}x${primaryDisplay.height} at (${primaryDisplay.x}, ${primaryDisplay.y})`);
+        console.log(`   Window: "${testWindow.title}" ${testWindow.width}x${testWindow.height} at (${testWindow.x}, ${testWindow.y})`);
+
+        // Calculate expected coordinates
+        console.log('\n📊 Expected transformation:');
+        console.log(`   Window top-left (${testWindow.x}, ${testWindow.y}) should become (0, 0)`);
+        console.log(`   Window bottom-right (${testWindow.x + testWindow.width}, ${testWindow.y + testWindow.height}) should become (${testWindow.width}, ${testWindow.height})`);
+
+        // Start cursor capture
+        const outputFile = `./test-output/primary-fix-test-${Date.now()}.json`;
+
+        await recorder.startCursorCapture(outputFile, {
+            windowRelative: true,
+            windowInfo: {
+                x: testWindow.x,
+                y: testWindow.y,
+                width: testWindow.width,
+                height: testWindow.height,
+                displayId: primaryDisplay.id
+            }
+        });
+
+        console.log('\n🖱️ Move mouse over the test window for 5 seconds...');
+        console.log(`   Try to move cursor to different corners of the window`);
+        console.log(`   Window boundaries: (0,0) to (${testWindow.width}, ${testWindow.height})`);
+
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        await recorder.stopCursorCapture();
+
+        // Analyze results
+        const fs = require('fs');
+        if (fs.existsSync(outputFile)) {
+            const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
+
+            console.log('\n📊 PRIMARY Display Test Results:');
+            console.log(`   Captured events: ${cursorData.length}`);
+
+            if (cursorData.length > 0) {
+                const inBounds = cursorData.filter(event =>
+                    event.x >= 0 && event.x < testWindow.width &&
+                    event.y >= 0 && event.y < testWindow.height
+                );
+
+                const outOfBounds = cursorData.filter(event =>
+                    event.x < 0 || event.x >= testWindow.width ||
+                    event.y < 0 || event.y >= testWindow.height
+                );
+
+                console.log(`   Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
+
+                if (outOfBounds.length > 0) {
+                    console.log(`   ❌ STILL HAVE ISSUES: ${outOfBounds.length} events out of bounds`);
+                    console.log(`   Sample problematic coordinates:`);
+                    outOfBounds.slice(0, 3).forEach(event => {
+                        console.log(`      (${event.x}, ${event.y}) - should be within 0-${testWindow.width}, 0-${testWindow.height}`);
+                    });
+                } else {
+                    console.log(`   ✅ ALL COORDINATES WITHIN BOUNDS - Primary display fix successful!`);
+                }
+
+                // Show coordinate range
+                const xCoords = cursorData.map(e => e.x);
+                const yCoords = cursorData.map(e => e.y);
+                const minX = Math.min(...xCoords);
+                const maxX = Math.max(...xCoords);
+                const minY = Math.min(...yCoords);
+                const maxY = Math.max(...yCoords);
+
+                console.log(`   Coordinate ranges: X=${minX} to ${maxX}, Y=${minY} to ${maxY}`);
+
+                // Check coordinate system
+                const firstEvent = cursorData[0];
+                console.log(`   Coordinate system: ${firstEvent.coordinateSystem}`);
+
+                if (firstEvent.coordinateSystem === "window-relative") {
+                    console.log(`   ✅ Coordinate system correctly set`);
+                } else {
+                    console.log(`   ❌ Coordinate system incorrect: ${firstEvent.coordinateSystem}`);
+                }
+            }
+        } else {
+            console.log('❌ No output file created');
+        }
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+    }
+}
+
+testPrimaryFix().catch(console.error);

package/test-output/cursor-test-window-1758264693010.json

@@ -1 +0,0 @@
-[{"x":758,"y":1089,"timestamp":37,"unixTimeMs":1758264693047,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":758,"y":1089,"timestamp":80,"unixTimeMs":1758264693090,"cursorType":"default","type":"mousedown","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":758,"y":1089,"timestamp":99,"unixTimeMs":1758264693109,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":758,"y":1089,"timestamp":180,"unixTimeMs":1758264693190,"cursorType":"default","type":"mouseup","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":758,"y":1089,"timestamp":201,"unixTimeMs":1758264693211,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":774,"y":1071,"timestamp":1610,"unixTimeMs":1758264694620,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":818,"y":1030,"timestamp":1631,"unixTimeMs":1758264694641,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":893,"y":972,"timestamp":1654,"unixTimeMs":1758264694664,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1015,"y":886,"timestamp":1677,"unixTimeMs":1758264694687,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1087,"y":843,"timestamp":1696,"unixTimeMs":1758264694706,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1233,"y":793,"timestamp":1714,"unixTimeMs":1758264694724,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1301,"y":776,"timestamp":1733,"unixTimeMs":1758264694743,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1360,"y":765,"timestamp":1755,"unixTimeMs":1758264694765,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1366,"y":764,"timestamp":1774,"unixTimeMs":1758264694784,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1363,"y":751,"timestamp":1814,"unixTimeMs":1758264694824,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1343,"y":709,"timestamp":1838,"unixTimeMs":1758264694848,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1335,"y":691,"timestamp":1855,"unixTimeMs":1758264694865,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1271,"y":583,"timestamp":1878,"unixTimeMs":1758264694888,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1250,"y":558,"timestamp":1898,"unixTimeMs":1758264694908,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1242,"y":552,"timestamp":1917,"unixTimeMs":1758264694927,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1238,"y":552,"timestamp":1937,"unixTimeMs":1758264694947,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1234,"y":554,"timestamp":1959,"unixTimeMs":1758264694969,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1233,"y":556,"timestamp":2207,"unixTimeMs":1758264695217,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1232,"y":559,"timestamp":2231,"unixTimeMs":1758264695241,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1232,"y":561,"timestamp":2252,"unixTimeMs":1758264695262,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1231,"y":565,"timestamp":2272,"unixTimeMs":1758264695282,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1231,"y":567,"timestamp":2290,"unixTimeMs":1758264695300,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1231,"y":595,"timestamp":2311,"unixTimeMs":1758264695321,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1236,"y":629,"timestamp":2330,"unixTimeMs":1758264695341,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1242,"y":647,"timestamp":2352,"unixTimeMs":1758264695362,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1251,"y":670,"timestamp":2369,"unixTimeMs":1758264695379,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1259,"y":702,"timestamp":2391,"unixTimeMs":1758264695401,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1265,"y":746,"timestamp":2409,"unixTimeMs":1758264695419,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1276,"y":763,"timestamp":2430,"unixTimeMs":1758264695440,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1272,"y":760,"timestamp":2985,"unixTimeMs":1758264695995,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1270,"y":758,"timestamp":3005,"unixTimeMs":1758264696015,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1269,"y":756,"timestamp":3047,"unixTimeMs":1758264696057,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1268,"y":754,"timestamp":3089,"unixTimeMs":1758264696099,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1268,"y":752,"timestamp":3132,"unixTimeMs":1758264696142,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1267,"y":750,"timestamp":3173,"unixTimeMs":1758264696183,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1266,"y":747,"timestamp":3215,"unixTimeMs":1758264696225,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1265,"y":745,"timestamp":3238,"unixTimeMs":1758264696248,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1263,"y":742,"timestamp":3278,"unixTimeMs":1758264696288,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1264,"y":740,"timestamp":3482,"unixTimeMs":1758264696492,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1266,"y":739,"timestamp":3522,"unixTimeMs":1758264696532,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1268,"y":738,"timestamp":3541,"unixTimeMs":1758264696551,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1277,"y":731,"timestamp":3563,"unixTimeMs":1758264696573,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1279,"y":730,"timestamp":3583,"unixTimeMs":1758264696593,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1281,"y":729,"timestamp":3688,"unixTimeMs":1758264696698,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1283,"y":727,"timestamp":3708,"unixTimeMs":1758264696718,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1286,"y":718,"timestamp":3873,"unixTimeMs":1758264696883,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1287,"y":713,"timestamp":3893,"unixTimeMs":1758264696903,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1289,"y":713,"timestamp":4204,"unixTimeMs":1758264697214,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}},{"x":1291,"y":713,"timestamp":4330,"unixTimeMs":1758264697340,"cursorType":"default","type":"move","coordinateSystem":"window-relative","windowInfo":{"width":3440,"height":1440,"displayId":null}}]