node-mac-recorder 2.17.21 → 2.18.1

package/src/cursor_tracker.mm

@@ -5,7 +5,6 @@
 #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;
@@ -13,7 +12,7 @@ static CFMachPortRef g_eventTap = NULL;
 static CFRunLoopSourceRef g_runLoopSource = NULL;
 static NSDate *g_trackingStartTime = nil;
 static NSString *g_outputPath = nil;
-static dispatch_source_t g_cursorTimer = nil;
+static NSTimer *g_cursorTimer = nil;
 static int g_debugCallbackCount = 0;
 static NSFileHandle *g_fileHandle = nil;
 static bool g_isFirstWrite = true;
@@ -23,78 +22,6 @@ 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;
@@ -108,17 +35,9 @@ NSString* detectCursorTypeFromCoreGraphics() {
 
 static CursorTimerTarget *g_timerTarget = nil;
 
-// Enhanced cursor state tracking with stability
+// Global cursor state tracking
 static NSString *g_lastDetectedCursorType = nil;
-static NSString *g_stableCursorType = @"default";
 static int g_cursorTypeCounter = 0;
-static NSTimeInterval g_lastCursorCheckTime = 0;
-static int g_sameCursorDetectionCount = 0;
-static NSString *g_pendingCursorType = nil;
-
-// 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;
@@ -130,204 +49,38 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Enhanced cursor type detection with multiple fallbacks and better image analysis
-NSString* detectCursorTypeFromNSCursor() {
-    @try {
-        // 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) {
-            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
-                    }
-                }
-            }
-        }
-
-        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]) {
-            return @"text";
-        } else if (currentCursor == [NSCursor pointingHandCursor]) {
-            return @"pointer";
-        } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
-            return @"col-resize";
-        } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
-            return @"ns-resize";
-        } else if (currentCursor == [NSCursor crosshairCursor]) {
-            return @"crosshair";
-        } else if (currentCursor == [NSCursor openHandCursor]) {
-            return @"grab";
-        } else if (currentCursor == [NSCursor closedHandCursor]) {
-            return @"grabbing";
-        } else if (currentCursor == [NSCursor operationNotAllowedCursor]) {
-            return @"not-allowed";
-        }
-
-        // Enhanced image analysis for better cursor detection
-        NSImage *cursorImage = [currentCursor image];
-        if (cursorImage) {
-            NSSize imageSize = [cursorImage size];
-            NSPoint hotSpot = [currentCursor hotSpot];
-
-            // 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) {
-                    // These are likely diagonal resize cursors
-                    // hotSpot can help distinguish between nwse and nesw
-                    if (hotSpot.x < imageSize.width / 2 && hotSpot.y < imageSize.height / 2) {
-                        return @"nwse-resize"; // northwest-southeast
-                    } else if (hotSpot.x > imageSize.width / 2 && hotSpot.y < imageSize.height / 2) {
-                        return @"nesw-resize"; // northeast-southwest
-                    }
-                }
-
-                // Check for horizontal/vertical resize cursors
-                if (imageSize.width > imageSize.height + 5) {
-                    return @"col-resize"; // horizontal resize
-                } else if (imageSize.height > imageSize.width + 5) {
-                    return @"ns-resize"; // vertical resize
-                }
-            }
-
-            // Text cursors typically have I-beam shape (narrow width)
-            if (imageSize.width < 8 && imageSize.height > 15) {
-                return @"text";
-            }
-        }
-
-        // Return nil to indicate we should use contextual detection
-        return nil;
-    } @catch (NSException *exception) {
-        return nil;
-    }
-}
-
-// Improved cursor type detection with stability and multi-layer approach
+// Cursor type detection helper - sistem genelindeki cursor type'ı al
 NSString* getCursorType() {
     @autoreleasepool {
         g_cursorTypeCounter++;
-        NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
-
+        
         @try {
-            // Layer 1: Fast NSCursor detection (high confidence cases)
-            NSString *nsCursorType = detectCursorTypeFromNSCursor();
-
-            // Layer 1.5: Core Graphics detection as primary fallback
-            NSString *cgCursorType = detectCursorTypeFromCoreGraphics();
-
-            // Layer 2: Optimized Accessibility API detection with caching
-            NSString *contextualCursorType = nil;
-
-            // 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();
-            }
+            // ACCESSIBILITY API BASED CURSOR DETECTION
+            // Determine cursor type based on the UI element under the cursor
 
+            CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
+            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
             AXUIElementRef elementAtPosition = NULL;
-            AXError error = AXUIElementCopyElementAtPosition(cachedSystemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+            AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+
+            NSString *cursorType = @"default"; // Default fallback
 
             if (error == kAXErrorSuccess && elementAtPosition) {
-                // Fast role detection with immediate processing
                 CFStringRef role = NULL;
                 error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
 
                 if (error == kAXErrorSuccess && role) {
                     NSString *elementRole = (__bridge_transfer NSString*)role;
+                    NSLog(@"🎯 ELEMENT ROLE: %@", elementRole);
 
-                    // TEXT CURSORS - high priority
+                    // TEXT CURSORS
                     if ([elementRole isEqualToString:@"AXTextField"] ||
                         [elementRole isEqualToString:@"AXTextArea"] ||
+                        [elementRole isEqualToString:@"AXStaticText"] ||
                         [elementRole isEqualToString:@"AXSearchField"]) {
-                        contextualCursorType = @"text";
+                        cursorType = @"text";
                     }
-                    // POINTER CURSORS - interactive elements with broader detection
+                    // POINTER CURSORS (clickable elements)
                     else if ([elementRole isEqualToString:@"AXLink"] ||
                              [elementRole isEqualToString:@"AXButton"] ||
                              [elementRole isEqualToString:@"AXMenuItem"] ||
@@ -335,182 +88,216 @@ NSString* getCursorType() {
                              [elementRole isEqualToString:@"AXCheckBox"] ||
                              [elementRole isEqualToString:@"AXPopUpButton"] ||
                              [elementRole isEqualToString:@"AXTab"]) {
-                        contextualCursorType = @"pointer";
-
-                        // Also check subroles for links and buttons
-                        CFStringRef subrole = NULL;
-                        AXError subroleError = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
-                        if (subroleError == kAXErrorSuccess && subrole) {
-                            NSString *elementSubrole = (__bridge_transfer NSString*)subrole;
-                            if ([elementSubrole isEqualToString:@"AXCloseButton"] ||
-                                [elementSubrole isEqualToString:@"AXMinimizeButton"] ||
-                                [elementSubrole isEqualToString:@"AXZoomButton"] ||
-                                [elementSubrole isEqualToString:@"AXToolbarButton"]) {
-                                contextualCursorType = @"pointer";
-                            }
-                        }
+                        cursorType = @"pointer";
                     }
-                    // WEB ELEMENTS - for web links that might not show as AXLink
-                    else if ([elementRole isEqualToString:@"AXGroup"] ||
-                             [elementRole isEqualToString:@"AXStaticText"]) {
-                        // Check if it's clickable/has action
-                        CFArrayRef actions = NULL;
-                        AXError actionsError = AXUIElementCopyActionNames(elementAtPosition, &actions);
-                        if (actionsError == kAXErrorSuccess && actions) {
-                            CFIndex actionCount = CFArrayGetCount(actions);
-                            for (CFIndex i = 0; i < actionCount; i++) {
-                                CFStringRef action = (CFStringRef)CFArrayGetValueAtIndex(actions, i);
-                                NSString *actionStr = (__bridge NSString*)action;
-                                if ([actionStr isEqualToString:@"AXPress"] ||
-                                    [actionStr isEqualToString:@"AXShowMenu"]) {
-                                    contextualCursorType = @"pointer";
-                                    break;
-                                }
-                            }
-                            CFRelease(actions);
+                    // GRAB CURSORS (draggable elements)
+                    else if ([elementRole isEqualToString:@"AXImage"] ||
+                             [elementRole isEqualToString:@"AXGroup"]) {
+                        // Check if element is draggable
+                        CFBooleanRef draggable = NULL;
+                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXMovable"), (CFTypeRef*)&draggable);
+                        if (error == kAXErrorSuccess && draggable && CFBooleanGetValue(draggable)) {
+                            cursorType = @"grab";
+                        } else {
+                            cursorType = @"default";
                         }
                     }
-                    // WINDOW BORDER RESIZE - critical for resize detection
-                    else if ([elementRole isEqualToString:@"AXWindow"]) {
-                        CFTypeRef position = NULL;
-                        CFTypeRef size = NULL;
-                        AXError posErr = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
-                        AXError sizeErr = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
-
-                        if (posErr == kAXErrorSuccess && sizeErr == kAXErrorSuccess && position && size) {
-                            CGPoint windowPos;
-                            CGSize windowSize;
-                            AXValueGetValue((AXValueRef)position, kAXValueTypeCGPoint, &windowPos);
-                            AXValueGetValue((AXValueRef)size, kAXValueTypeCGSize, &windowSize);
-
-                            CGFloat x = cursorPos.x - windowPos.x;
-                            CGFloat y = cursorPos.y - windowPos.y;
-                            CGFloat w = windowSize.width;
-                            CGFloat h = windowSize.height;
-                            CGFloat edge = 5.0; // 5px edge detection
-
-                            // Corner resize detection
-                            if (x <= edge && y <= edge) {
-                                contextualCursorType = @"nwse-resize";
-                            }
-                            else if (x >= w-edge && y <= edge) {
-                                contextualCursorType = @"nesw-resize";
-                            }
-                            else if (x <= edge && y >= h-edge) {
-                                contextualCursorType = @"nesw-resize";
-                            }
-                            else if (x >= w-edge && y >= h-edge) {
-                                contextualCursorType = @"nwse-resize";
-                            }
-                            // Edge resize detection
-                            else if (x <= edge || x >= w-edge) {
-                                contextualCursorType = @"col-resize";
-                            }
-                            else if (y <= edge || y >= h-edge) {
-                                contextualCursorType = @"ns-resize";
-                            }
-
-                            if (position) CFRelease(position);
-                            if (size) CFRelease(size);
-                        }
+                    // PROGRESS CURSORS (loading/busy elements)
+                    else if ([elementRole isEqualToString:@"AXProgressIndicator"] ||
+                             [elementRole isEqualToString:@"AXBusyIndicator"]) {
+                        cursorType = @"progress";
                     }
-                    // SPLITTER RESIZE
+                    // HELP CURSORS (help buttons/tooltips)
+                    else if ([elementRole isEqualToString:@"AXHelpTag"] ||
+                             [elementRole isEqualToString:@"AXTooltip"]) {
+                        cursorType = @"help";
+                    }
+                    // RESIZE CURSORS - sadece AXSplitter için
                     else if ([elementRole isEqualToString:@"AXSplitter"]) {
+                        // Get splitter orientation to determine resize direction
                         CFStringRef orientation = NULL;
                         error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXOrientation"), (CFTypeRef*)&orientation);
                         if (error == kAXErrorSuccess && orientation) {
                             NSString *orientationStr = (__bridge_transfer NSString*)orientation;
                             if ([orientationStr isEqualToString:@"AXHorizontalOrientation"]) {
-                                contextualCursorType = @"ns-resize";
+                                cursorType = @"ns-resize"; // Yatay splitter -> dikey hareket (north-south)
                             } else if ([orientationStr isEqualToString:@"AXVerticalOrientation"]) {
-                                contextualCursorType = @"col-resize";
+                                cursorType = @"col-resize"; // Dikey splitter -> yatay hareket (east-west)
+                            } else {
+                                cursorType = @"default"; // Bilinmeyen orientation
                             }
+                        } else {
+                            cursorType = @"default"; // Orientation alınamazsa default
                         }
                     }
-                    // PROGRESS INDICATORS
-                    else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
-                        contextualCursorType = @"progress";
+                    // SCROLL CURSORS - hep default olsun, all-scroll görünmesin
+                    else if ([elementRole isEqualToString:@"AXScrollBar"]) {
+                        cursorType = @"default"; // ScrollBar'lar için de default
+                    }
+                    // AXScrollArea - hep default
+                    else if ([elementRole isEqualToString:@"AXScrollArea"]) {
+                        cursorType = @"default"; // ScrollArea her zaman default
+                    }
+                    // CROSSHAIR CURSORS (drawing/selection tools)
+                    else if ([elementRole isEqualToString:@"AXCanvas"] ||
+                             [elementRole isEqualToString:@"AXDrawingArea"]) {
+                        cursorType = @"crosshair";
+                    }
+                    // ZOOM CURSORS (zoom controls)
+                    else if ([elementRole isEqualToString:@"AXZoomButton"]) {
+                        cursorType = @"zoom-in";
                     }
-                    // DEFAULT AREAS - explicitly set default for known non-interactive elements
-                    else if ([elementRole isEqualToString:@"AXApplication"] ||
-                             [elementRole isEqualToString:@"AXWindow"] ||
-                             [elementRole isEqualToString:@"AXScrollArea"] ||
-                             [elementRole isEqualToString:@"AXScrollBar"] ||
-                             [elementRole isEqualToString:@"AXStaticText"] ||
+                    // NOT-ALLOWED CURSORS (disabled elements)
+                    else if ([elementRole isEqualToString:@"AXStaticText"] ||
                              [elementRole isEqualToString:@"AXGroup"]) {
-                        // These are typically non-interactive - should be default cursor
-                        contextualCursorType = @"default";
+                        // Check if element is disabled/readonly
+                        CFBooleanRef enabled = NULL;
+                        error = AXUIElementCopyAttributeValue(elementAtPosition, kAXEnabledAttribute, (CFTypeRef*)&enabled);
+                        if (error == kAXErrorSuccess && enabled && !CFBooleanGetValue(enabled)) {
+                            cursorType = @"not-allowed";
+                        }
+                    }
+                    // WINDOW BORDER RESIZE - sadece pencere kenarlarında
+                    else if ([elementRole isEqualToString:@"AXWindow"]) {
+                        // Check window attributes to see if it's resizable
+                        CFBooleanRef resizable = NULL;
+                        AXError resizableError = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXResizeButton"), (CFTypeRef*)&resizable);
+
+                        // Sadece resize edilebilir pencereler için cursor değişimi
+                        if (resizableError == kAXErrorSuccess || true) { // AXResizeButton bulunamazsa da devam et
+                            CFTypeRef position = NULL;
+                            CFTypeRef size = NULL;
+                            error = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
+                            AXError sizeError = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
+
+                            if (error == kAXErrorSuccess && sizeError == kAXErrorSuccess && position && size) {
+                                CGPoint windowPos;
+                                CGSize windowSize;
+                                AXValueGetValue((AXValueRef)position, kAXValueTypeCGPoint, &windowPos);
+                                AXValueGetValue((AXValueRef)size, kAXValueTypeCGSize, &windowSize);
+
+                                CGFloat x = cursorPos.x - windowPos.x;
+                                CGFloat y = cursorPos.y - windowPos.y;
+                                CGFloat w = windowSize.width;
+                                CGFloat h = windowSize.height;
+                                CGFloat edge = 3.0; // Daha küçük edge detection (3px)
+
+                                // Sadece çok kenar köşelerde resize cursor'ı göster
+                                BOOL isOnBorder = NO;
+
+                                // Corner resize detection - çok dar alanda, doğru açılar
+                                if (x <= edge && y <= edge) {
+                                    cursorType = @"nwse-resize"; // Sol üst köşe - northwest-southeast
+                                    isOnBorder = YES;
+                                }
+                                else if (x >= w-edge && y <= edge) {
+                                    cursorType = @"nesw-resize"; // Sağ üst köşe - northeast-southwest
+                                    isOnBorder = YES;
+                                }
+                                else if (x <= edge && y >= h-edge) {
+                                    cursorType = @"nesw-resize"; // Sol alt köşe - southwest-northeast
+                                    isOnBorder = YES;
+                                }
+                                else if (x >= w-edge && y >= h-edge) {
+                                    cursorType = @"nwse-resize"; // Sağ alt köşe - southeast-northwest
+                                    isOnBorder = YES;
+                                }
+                                // Edge resize detection - sadece çok kenarlarda
+                                else if (x <= edge && y > edge && y < h-edge) {
+                                    cursorType = @"col-resize"; // Sol kenar - column resize (yatay)
+                                    isOnBorder = YES;
+                                }
+                                else if (x >= w-edge && y > edge && y < h-edge) {
+                                    cursorType = @"col-resize"; // Sağ kenar - column resize (yatay)
+                                    isOnBorder = YES;
+                                }
+                                else if (y <= edge && x > edge && x < w-edge) {
+                                    cursorType = @"ns-resize"; // Üst kenar - north-south resize (dikey)
+                                    isOnBorder = YES;
+                                }
+                                else if (y >= h-edge && x > edge && x < w-edge) {
+                                    cursorType = @"ns-resize"; // Alt kenar - north-south resize (dikey)
+                                    isOnBorder = YES;
+                                }
+
+                                // Eğer border'da değilse default
+                                if (!isOnBorder) {
+                                    cursorType = @"default";
+                                }
+
+                                if (position) CFRelease(position);
+                                if (size) CFRelease(size);
+                            } else {
+                                cursorType = @"default";
+                            }
+                        } else {
+                            cursorType = @"default";
+                        }
                     }
-                    // OTHER ELEMENTS - let NSCursor handle or default
+                    // HER DURUM İÇİN DEFAULT FALLBACK
                     else {
-                        contextualCursorType = nil;
+                        // Bilinmeyen elementler için her zaman default
+                        cursorType = @"default";
                     }
-                }
-                CFRelease(elementAtPosition);
-            }
 
-            // Layer 3: Enhanced multi-layer priority detection
-            NSString *detectedCursorType = @"default";
+                    // Check subroles for additional context
+                    CFStringRef subrole = NULL;
+                    error = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
+                    if (error == kAXErrorSuccess && subrole) {
+                        NSString *elementSubrole = (__bridge_transfer NSString*)subrole;
+                        NSLog(@"🎯 ELEMENT SUBROLE: %@", elementSubrole);
+
+                        // Subrole override'ları - sadece çok spesifik durumlar için
+                        if ([elementSubrole isEqualToString:@"AXCloseButton"] ||
+                            [elementSubrole isEqualToString:@"AXMinimizeButton"] ||
+                            [elementSubrole isEqualToString:@"AXZoomButton"] ||
+                            [elementSubrole isEqualToString:@"AXToolbarButton"]) {
+                            cursorType = @"pointer";
+                        }
+                        // Copy/alias subroles - sadece bu durumlar için override
+                        else if ([elementSubrole isEqualToString:@"AXFileDrop"] ||
+                                 [elementSubrole isEqualToString:@"AXDropTarget"]) {
+                            cursorType = @"copy";
+                        }
+                        // Alias/shortcut subroles
+                        else if ([elementSubrole isEqualToString:@"AXAlias"] ||
+                                 [elementSubrole isEqualToString:@"AXShortcut"]) {
+                            cursorType = @"alias";
+                        }
+                        // Grabbing state (being dragged) - sadece gerçek drag sırasında
+                        else if ([elementSubrole isEqualToString:@"AXDragging"] ||
+                                 [elementSubrole isEqualToString:@"AXMoving"]) {
+                            cursorType = @"grabbing";
+                        }
+                        // Zoom controls - sadece spesifik zoom butonları için
+                        else if ([elementSubrole isEqualToString:@"AXZoomIn"]) {
+                            cursorType = @"zoom-in";
+                        }
+                        else if ([elementSubrole isEqualToString:@"AXZoomOut"]) {
+                            cursorType = @"zoom-out";
+                        }
+                        // Subrole'dan bir şey bulamazsa role-based cursor'ı koruyoruz
+                    }
+                }
 
-            // 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. If NSCursor gives reliable results, use them
-            else if (nsCursorType != nil &&
-                     ([nsCursorType isEqualToString:@"text"] ||
-                      [nsCursorType isEqualToString:@"pointer"] ||
-                      [nsCursorType hasSuffix:@"resize"])) {
-                // Trust NSCursor for these specific types
-                detectedCursorType = nsCursorType;
-            }
-            // 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";
+                CFRelease(elementAtPosition);
             }
 
-            // Layer 4: Ultra-responsive detection with minimal stabilization
-            NSString *finalCursorType = detectedCursorType;
-
-            // Ultra-fast response - immediate updates for all cursor types
-            if (currentTime - g_lastCursorCheckTime > CURSOR_STABILITY_THRESHOLD) {
-                // 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 {
-                // Still use immediate update for ultra-responsiveness
-                // Only apply minimal delay for very rapid changes
-                finalCursorType = detectedCursorType;
+            if (systemWide) {
+                CFRelease(systemWide);
             }
 
-            // Final fallback validation
-            if (!finalCursorType || [finalCursorType length] == 0) {
-                finalCursorType = @"default";
+            // Son güvence - eğer cursorType hala nil veya geçersizse default'a çevir
+            if (!cursorType || [cursorType length] == 0) {
+                cursorType = @"default";
             }
 
-            // Debug logging for stability tracking
-            NSLog(@"🎯 CURSOR DETECTION - NSCursor: %@, Contextual: %@, Stable: %@, Count: %d",
-                  nsCursorType, contextualCursorType, finalCursorType, g_sameCursorDetectionCount);
-
-            return finalCursorType;
-
+            NSLog(@"🎯 FINAL CURSOR TYPE: %@", cursorType);
+            return cursorType;
+            
         } @catch (NSException *exception) {
             NSLog(@"Error in getCursorType: %@", exception);
-            return g_stableCursorType ?: @"default";
+            return @"default";
         }
     }
 }
@@ -601,15 +388,13 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         }
         
         // Cursor data oluştur
-        // Cursor data oluştur - global koordinat sistemi kullan
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
             @"y": @((int)location.y),
             @"timestamp": @(timestamp),
             @"unixTimeMs": @(unixTimeMs),
             @"cursorType": cursorType,
-            @"type": eventType,
-            @"coordinateSystem": @"global"
+            @"type": eventType
         };
         
         // Direkt dosyaya yaz
@@ -623,16 +408,8 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
 void cursorTimerCallback() {
     @autoreleasepool {
         g_debugCallbackCount++; // Timer callback çağrıldığını say
-
-        static int callCount = 0;
-        callCount++;
-        if (callCount <= 3) {
-            NSLog(@"🔄 Timer callback #%d called", callCount);
-        }
-
+        
         if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) {
-            NSLog(@"❌ Timer callback stopped - tracking:%d, startTime:%@, fileHandle:%@",
-                  g_isCursorTracking, g_trackingStartTime ? @"OK" : @"nil", g_fileHandle ? @"OK" : @"nil");
             return;
         }
         
@@ -661,15 +438,13 @@ void cursorTimerCallback() {
         NSString *cursorType = getCursorType();
         
         // Cursor data oluştur
-        // Cursor data oluştur - global koordinat sistemi kullan
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
             @"y": @((int)location.y),
             @"timestamp": @(timestamp),
             @"unixTimeMs": @(unixTimeMs),
             @"cursorType": cursorType,
-            @"type": @"move",
-            @"coordinateSystem": @"global"
+            @"type": @"move"
         };
         
         // Direkt dosyaya yaz
@@ -681,14 +456,16 @@ void cursorTimerCallback() {
 void cleanupCursorTracking() {
     g_isCursorTracking = false;
     
-    // GCD Timer temizle
+    // Timer temizle
     if (g_cursorTimer) {
-        dispatch_source_cancel(g_cursorTimer);
-        dispatch_release(g_cursorTimer);
+        [g_cursorTimer invalidate];
         g_cursorTimer = nil;
     }
     
-    // Timer target artık kullanılmıyor (GCD kullanıyoruz)
+    if (g_timerTarget) {
+        [g_timerTarget autorelease];
+        g_timerTarget = nil;
+    }
     
     // Dosyayı önce kapat (en önemli işlem)
     if (g_fileHandle) {
@@ -724,11 +501,7 @@ void cleanupCursorTracking() {
     g_outputPath = nil;
     g_debugCallbackCount = 0;
     g_lastDetectedCursorType = nil;
-    g_stableCursorType = @"default";
     g_cursorTypeCounter = 0;
-    g_lastCursorCheckTime = 0;
-    g_sameCursorDetectionCount = 0;
-    g_pendingCursorType = nil;
     g_isFirstWrite = true;
 }
 
@@ -794,30 +567,19 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
             CGEventTapEnable(g_eventTap, true);
         }
         
-        // GCD Timer kullan (Node.js ile uyumlu)
-        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
-        g_cursorTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
-
-        if (g_cursorTimer) {
-            dispatch_source_set_timer(g_cursorTimer,
-                                     dispatch_time(DISPATCH_TIME_NOW, 50 * NSEC_PER_MSEC), // Start after 50ms
-                                     50 * NSEC_PER_MSEC, // Repeat every 50ms (20 FPS)
-                                     10 * NSEC_PER_MSEC); // Leeway of 10ms
-
-            dispatch_source_set_event_handler(g_cursorTimer, ^{
-                cursorTimerCallback();
-            });
-
-            dispatch_resume(g_cursorTimer);
-        }
-
+        // NSTimer kullan (main thread'de çalışır)
+        g_timerTarget = [[CursorTimerTarget alloc] init];
+        
+        g_cursorTimer = [NSTimer timerWithTimeInterval:0.05 // 50ms (20 FPS)
+                                                target:g_timerTarget
+                                              selector:@selector(timerCallback:)
+                                              userInfo:nil
+                                               repeats:YES];
+        
+        // Main run loop'a ekle
+        [[NSRunLoop mainRunLoop] addTimer:g_cursorTimer forMode:NSRunLoopCommonModes];
+        
         g_isCursorTracking = true;
-
-        NSLog(@"🎯 Native cursor tracking started with timer and event tap");
-        NSLog(@"🎯 File handle: %@", g_fileHandle ? @"OK" : @"FAILED");
-        NSLog(@"🎯 Timer: %@", g_cursorTimer ? @"OK" : @"FAILED");
-        NSLog(@"🎯 Event tap: %@", g_eventTap ? @"OK" : @"FAILED");
-
         return Napi::Boolean::New(env, true);
         
     } @catch (NSException *exception) {