node-mac-recorder 2.20.2 → 2.20.4

package/package.json

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

package/src/cursor_tracker.mm

@@ -7,6 +7,10 @@
 #import <Accessibility/Accessibility.h>
 #import <dispatch/dispatch.h>
 
+#ifndef kAXHitTestParameterizedAttribute
+#define kAXHitTestParameterizedAttribute CFSTR("AXHitTest")
+#endif
+
 // Global state for cursor tracking
 static bool g_isCursorTracking = false;
 static CFMachPortRef g_eventTap = NULL;
@@ -49,309 +53,330 @@ static NSString* CopyAndReleaseCFString(CFStringRef value) {
     return result;
 }
 
-// Mouse button state tracking
-static bool g_leftMouseDown = false;
-static bool g_rightMouseDown = false;
-static NSString *g_lastEventType = @"move";
+static inline BOOL StringEqualsAny(NSString *value, NSArray<NSString *> *candidates) {
+    if (!value) {
+        return NO;
+    }
+    for (NSString *candidate in candidates) {
+        if ([value isEqualToString:candidate]) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+static NSString* CopyAttributeString(AXUIElementRef element, CFStringRef attribute) {
+    if (!element || !attribute) {
+        return nil;
+    }
 
-// Event tap callback
-static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *userInfo) {
-    return event;
+    CFStringRef value = NULL;
+    AXError error = AXUIElementCopyAttributeValue(element, attribute, (CFTypeRef *)&value);
+    if (error == kAXErrorSuccess && value) {
+        return CopyAndReleaseCFString(value);
+    }
+
+    if (value) {
+        CFRelease(value);
+    }
+    return nil;
 }
 
-// Accessibility tabanlı cursor tip tespiti
-static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
-    @autoreleasepool {
-        @try {
-            // ACCESSIBILITY API BASED CURSOR DETECTION
-            // Determine cursor type based on the UI element under the cursor
+static BOOL CopyAttributeBoolean(AXUIElementRef element, CFStringRef attribute, BOOL *outValue) {
+    if (!element || !attribute || !outValue) {
+        return NO;
+    }
 
-            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
-            AXUIElementRef elementAtPosition = NULL;
-            AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+    CFTypeRef rawValue = NULL;
+    AXError error = AXUIElementCopyAttributeValue(element, attribute, &rawValue);
+    if (error != kAXErrorSuccess || !rawValue) {
+        if (rawValue) {
+            CFRelease(rawValue);
+        }
+        return NO;
+    }
 
-            NSString *cursorType = @"default"; // Default fallback
+    BOOL result = NO;
+    if (CFGetTypeID(rawValue) == CFBooleanGetTypeID()) {
+        result = CFBooleanGetValue((CFBooleanRef)rawValue);
+    }
 
-            if (error == kAXErrorSuccess && elementAtPosition) {
-                NSString *elementRole = nil;
-                CFStringRef role = NULL;
-                error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
-                if (error == kAXErrorSuccess && role) {
-                    elementRole = CopyAndReleaseCFString(role);
-                }
+    CFRelease(rawValue);
+    *outValue = result;
+    return YES;
+}
 
-                if (elementRole) {
-                    NSLog(@"🎯 ELEMENT ROLE: %@", elementRole);
-                }
+static BOOL ElementHasAction(AXUIElementRef element, CFStringRef action) {
+    if (!element || !action) {
+        return NO;
+    }
 
-                // TEXT CURSORS
-                if ([elementRole isEqualToString:@"AXTextField"] ||
-                    [elementRole isEqualToString:@"AXTextArea"] ||
-                    [elementRole isEqualToString:@"AXStaticText"] ||
-                    [elementRole isEqualToString:@"AXSearchField"]) {
-                    cursorType = @"text";
-                }
-                // POINTER CURSORS (clickable elements)
-                else if ([elementRole isEqualToString:@"AXLink"] ||
-                         [elementRole isEqualToString:@"AXButton"] ||
-                         [elementRole isEqualToString:@"AXMenuItem"] ||
-                         [elementRole isEqualToString:@"AXRadioButton"] ||
-                         [elementRole isEqualToString:@"AXCheckBox"] ||
-                         [elementRole isEqualToString:@"AXPopUpButton"] ||
-                         [elementRole isEqualToString:@"AXTab"]) {
-                    cursorType = @"pointer";
-                }
-                // 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";
-                    }
-                }
-                // PROGRESS CURSORS (loading/busy elements)
-                else if ([elementRole isEqualToString:@"AXProgressIndicator"] ||
-                         [elementRole isEqualToString:@"AXBusyIndicator"]) {
-                    cursorType = @"progress";
-                }
-                // 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 = CopyAndReleaseCFString(orientation);
-                        if ([orientationStr isEqualToString:@"AXHorizontalOrientation"]) {
-                            cursorType = @"ns-resize"; // Yatay splitter -> dikey hareket (north-south)
-                        } else if ([orientationStr isEqualToString:@"AXVerticalOrientation"]) {
-                            cursorType = @"col-resize"; // Dikey splitter -> yatay hareket (east-west)
-                        } else {
-                            cursorType = @"default"; // Bilinmeyen orientation
-                        }
-                    } else {
-                        cursorType = @"default"; // Orientation alınamazsa default
-                    }
-                }
-                // 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";
-                }
-                // NOT-ALLOWED CURSORS (disabled elements)
-                else if ([elementRole isEqualToString:@"AXStaticText"] ||
-                         [elementRole isEqualToString:@"AXGroup"]) {
-                    // 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";
-                    }
-                }
-                // HER DURUM İÇİN DEFAULT FALLBACK
-                else {
-                    // Bilinmeyen elementler için her zaman default
-                    cursorType = @"default";
-                }
+    CFArrayRef actions = NULL;
+    AXError error = AXUIElementCopyActionNames(element, &actions);
+    if (error != kAXErrorSuccess || !actions) {
+        return NO;
+    }
 
-                // Check subroles for additional context
-                CFStringRef subrole = NULL;
-                error = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
-                if (error == kAXErrorSuccess && subrole) {
-                    NSString *elementSubrole = CopyAndReleaseCFString(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
-                }
+    BOOL hasAction = NO;
+    CFIndex count = CFArrayGetCount(actions);
+    for (CFIndex i = 0; i < count; i++) {
+        CFStringRef candidate = (CFStringRef)CFArrayGetValueAtIndex(actions, i);
+        if (CFStringCompare(candidate, action, 0) == kCFCompareEqualTo) {
+            hasAction = YES;
+            break;
+        }
+    }
+    CFRelease(actions);
+    return hasAction;
+}
 
-                CFStringRef roleDescriptionRef = NULL;
-                AXError descriptionError = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleDescriptionAttribute, (CFTypeRef*)&roleDescriptionRef);
-                if (descriptionError == kAXErrorSuccess && roleDescriptionRef) {
-                    NSString *roleDescription = CopyAndReleaseCFString(roleDescriptionRef);
-                    if (roleDescription) {
-                        NSString *roleDescriptionLower = [roleDescription lowercaseString];
-                        if ([roleDescriptionLower containsString:@"text"] ||
-                            [roleDescriptionLower containsString:@"editor"] ||
-                            [roleDescriptionLower containsString:@"code"] ||
-                            [roleDescriptionLower containsString:@"document"]) {
-                            cursorType = @"text";
-                        } else if ([roleDescriptionLower containsString:@"button"] ||
-                                   [roleDescriptionLower containsString:@"link"] ||
-                                   [roleDescriptionLower containsString:@"tab"]) {
-                            cursorType = @"pointer";
-                        }
-                    }
-                }
+static BOOL PointInsideElementFrame(AXUIElementRef element, CGPoint point) {
+    if (!element) {
+        return NO;
+    }
 
-                CFBooleanRef isEditable = NULL;
-                if (AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXEditable"), (CFTypeRef*)&isEditable) == kAXErrorSuccess &&
-                    isEditable && CFBooleanGetValue(isEditable)) {
-                    cursorType = @"text";
-                }
+    AXValueRef positionValue = NULL;
+    AXValueRef sizeValue = NULL;
 
-                CFBooleanRef supportsTextSelection = NULL;
-                if (AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXSupportsTextSelection"), (CFTypeRef*)&supportsTextSelection) == kAXErrorSuccess &&
-                    supportsTextSelection && CFBooleanGetValue(supportsTextSelection)) {
-                    cursorType = @"text";
-                }
+    AXError positionError = AXUIElementCopyAttributeValue(element, kAXPositionAttribute, (CFTypeRef *)&positionValue);
+    AXError sizeError = AXUIElementCopyAttributeValue(element, kAXSizeAttribute, (CFTypeRef *)&sizeValue);
 
-                CFTypeRef valueAttribute = NULL;
-                if (AXUIElementCopyAttributeValue(elementAtPosition, kAXValueAttribute, &valueAttribute) == kAXErrorSuccess && valueAttribute) {
-                    CFTypeID typeId = CFGetTypeID(valueAttribute);
-                    if (typeId == CFAttributedStringGetTypeID() ||
-                        typeId == CFStringGetTypeID()) {
-                        cursorType = @"text";
-                    }
-                    CFRelease(valueAttribute);
-                }
+    if (positionError != kAXErrorSuccess || sizeError != kAXErrorSuccess || !positionValue || !sizeValue) {
+        if (positionValue) CFRelease(positionValue);
+        if (sizeValue) CFRelease(sizeValue);
+        return NO;
+    }
 
-            }
+    CGPoint origin = CGPointZero;
+    CGSize size = CGSizeZero;
+    AXValueGetValue(positionValue, kAXValueTypeCGPoint, &origin);
+    AXValueGetValue(sizeValue, kAXValueTypeCGSize, &size);
 
-            if (elementAtPosition) {
-                CFRelease(elementAtPosition);
-            }
-            if (systemWide) {
-                CFRelease(systemWide);
-            }
+    CFRelease(positionValue);
+    CFRelease(sizeValue);
+
+    CGRect frame = CGRectMake(origin.x, origin.y, size.width, size.height);
+    return CGRectContainsPoint(frame, point);
+}
+
+static NSString* CursorTypeForWindowBorder(AXUIElementRef element, CGPoint cursorPos) {
+    AXValueRef positionValue = NULL;
+    AXValueRef sizeValue = NULL;
+
+    AXError positionError = AXUIElementCopyAttributeValue(element, kAXPositionAttribute, (CFTypeRef *)&positionValue);
+    AXError sizeError = AXUIElementCopyAttributeValue(element, kAXSizeAttribute, (CFTypeRef *)&sizeValue);
 
-            // Son güvence - eğer cursorType hala nil veya geçersizse default'a çevir
-            if (!cursorType || [cursorType length] == 0) {
-                cursorType = @"default";
+    if (positionError != kAXErrorSuccess || sizeError != kAXErrorSuccess || !positionValue || !sizeValue) {
+        if (positionValue) CFRelease(positionValue);
+        if (sizeValue) CFRelease(sizeValue);
+        return nil;
+    }
+
+    CGPoint windowOrigin = CGPointZero;
+    CGSize windowSize = CGSizeZero;
+    AXValueGetValue(positionValue, kAXValueTypeCGPoint, &windowOrigin);
+    AXValueGetValue(sizeValue, kAXValueTypeCGSize, &windowSize);
+
+    CFRelease(positionValue);
+    CFRelease(sizeValue);
+
+    CGFloat edge = 4.0;
+    CGFloat x = cursorPos.x - windowOrigin.x;
+    CGFloat y = cursorPos.y - windowOrigin.y;
+    CGFloat w = windowSize.width;
+    CGFloat h = windowSize.height;
+
+    if (x < 0 || y < 0 || x > w || y > h) {
+        return nil;
+    }
+
+    BOOL nearLeft = (x >= 0 && x <= edge);
+    BOOL nearRight = (x >= w - edge && x <= w);
+    BOOL nearTop = (y >= 0 && y <= edge);
+    BOOL nearBottom = (y >= h - edge && y <= h);
+
+    if ((nearLeft && nearTop) || (nearRight && nearBottom)) {
+        return @"nwse-resize";
+    }
+    if ((nearRight && nearTop) || (nearLeft && nearBottom)) {
+        return @"nesw-resize";
+    }
+    if (nearLeft || nearRight) {
+        return @"col-resize";
+    }
+    if (nearTop || nearBottom) {
+        return @"ns-resize";
+    }
+
+    return nil;
+}
+
+static NSString* CursorTypeFromAccessibilityElement(AXUIElementRef element, CGPoint cursorPos) {
+    if (!element) {
+        return nil;
+    }
+
+    NSString *role = CopyAttributeString(element, kAXRoleAttribute);
+    NSString *subrole = CopyAttributeString(element, kAXSubroleAttribute);
+    NSString *roleDescription = CopyAttributeString(element, kAXRoleDescriptionAttribute);
+
+    if (StringEqualsAny(role, @[@"AXTextField", @"AXTextArea", @"AXSearchField"])) {
+        return @"text";
+    }
+
+    if (StringEqualsAny(subrole, @[@"AXSecureTextField", @"AXTextField"])) {
+        return @"text";
+    }
+
+    BOOL isEditable = NO;
+    if (CopyAttributeBoolean(element, CFSTR("AXEditable"), &isEditable) && isEditable) {
+        return @"text";
+    }
+
+    BOOL supportsSelection = NO;
+    if (CopyAttributeBoolean(element, CFSTR("AXSupportsTextSelection"), &supportsSelection) && supportsSelection) {
+        return @"text";
+    }
+
+    CFTypeRef valueAttribute = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXValueAttribute, &valueAttribute) == kAXErrorSuccess && valueAttribute) {
+        CFTypeID typeId = CFGetTypeID(valueAttribute);
+        if (typeId == CFAttributedStringGetTypeID() || typeId == CFStringGetTypeID()) {
+            CFRelease(valueAttribute);
+            return @"text";
+        }
+        CFRelease(valueAttribute);
+    }
+
+    if (StringEqualsAny(role, @[@"AXProgressIndicator", @"AXBusyIndicator"])) {
+        return @"progress";
+    }
+
+    if (StringEqualsAny(role, @[@"AXHelpTag", @"AXTooltip"])) {
+        return @"help";
+    }
+
+    if ([role isEqualToString:@"AXSplitter"]) {
+        NSString *orientation = CopyAttributeString(element, CFSTR("AXOrientation"));
+        if ([orientation isEqualToString:@"AXHorizontalOrientation"]) {
+            return @"ns-resize";
+        }
+        if ([orientation isEqualToString:@"AXVerticalOrientation"]) {
+            return @"col-resize";
+        }
+    }
+
+    if ([role isEqualToString:@"AXWindow"]) {
+        NSString *windowCursor = CursorTypeForWindowBorder(element, cursorPos);
+        if (windowCursor) {
+            return windowCursor;
+        }
+    }
+
+    if (StringEqualsAny(role, @[@"AXMenuItem", @"AXButton", @"AXLink", @"AXTab", @"AXRadioButton", @"AXCheckBox", @"AXPopUpButton"])) {
+        return @"pointer";
+    }
+
+    if (StringEqualsAny(subrole, @[@"AXLink", @"AXToolbarButton", @"AXFileDrop", @"AXDropTarget"])) {
+        return @"pointer";
+    }
+
+    if (roleDescription) {
+        NSString *lower = [roleDescription lowercaseString];
+        if ([lower containsString:@"button"] ||
+            [lower containsString:@"link"] ||
+            [lower containsString:@"tab"]) {
+            return @"pointer";
+        }
+        if ([lower containsString:@"text"] ||
+            [lower containsString:@"editor"] ||
+            [lower containsString:@"document"]) {
+            return @"text";
+        }
+    }
+
+    if (ElementHasAction(element, kAXPressAction) ||
+        ElementHasAction(element, kAXShowMenuAction) ||
+        ElementHasAction(element, CFSTR("AXConfirm"))) {
+        return @"pointer";
+    }
+
+    CFTypeRef urlValue = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXURLAttribute, &urlValue) == kAXErrorSuccess && urlValue) {
+        CFRelease(urlValue);
+        return @"pointer";
+    }
+    if (urlValue) {
+        CFRelease(urlValue);
+    }
+
+    BOOL isDraggable = NO;
+    if (CopyAttributeBoolean(element, CFSTR("AXDraggable"), &isDraggable) && isDraggable) {
+        return @"grab";
+    }
+
+    BOOL isMovable = NO;
+    if (CopyAttributeBoolean(element, CFSTR("AXMovable"), &isMovable) && isMovable) {
+        return @"grab";
+    }
+
+    if (subrole && [subrole isEqualToString:@"AXZoomIn"]) {
+        return @"zoom-in";
+    }
+    if (subrole && [subrole isEqualToString:@"AXZoomOut"]) {
+        return @"zoom-out";
+    }
+
+    return nil;
+}
+
+// Mouse button state tracking
+static bool g_leftMouseDown = false;
+static bool g_rightMouseDown = false;
+static NSString *g_lastEventType = @"move";
+
+// Accessibility tabanlı cursor tip tespiti
+static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
+    @autoreleasepool {
+        AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+        if (!systemWide) {
+            return nil;
+        }
+
+        NSString *cursorType = nil;
+
+        AXUIElementRef elementAtPosition = NULL;
+        AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+        if (error == kAXErrorSuccess && elementAtPosition) {
+            cursorType = CursorTypeFromAccessibilityElement(elementAtPosition, cursorPos);
+            CFRelease(elementAtPosition);
+        }
+
+        if (!cursorType) {
+            AXValueRef pointValue = AXValueCreate(kAXValueTypeCGPoint, &cursorPos);
+            if (pointValue) {
+                AXUIElementRef hitElement = NULL;
+                AXError hitError = AXUIElementCopyParameterizedAttributeValue(systemWide, kAXHitTestParameterizedAttribute, pointValue, (CFTypeRef *)&hitElement);
+                CFRelease(pointValue);
+                if (hitError == kAXErrorSuccess && hitElement) {
+                    cursorType = CursorTypeFromAccessibilityElement(hitElement, cursorPos);
+                    CFRelease(hitElement);
+                }
             }
+        }
 
-            NSLog(@"🎯 AX CURSOR TYPE: %@", cursorType);
-            return cursorType;
-            
-        } @catch (NSException *exception) {
-            NSLog(@"Error in detectCursorTypeUsingAccessibility: %@", exception);
-            return @"default";
+        if (!cursorType) {
+            AXUIElementRef focusedElement = NULL;
+            if (AXUIElementCopyAttributeValue(systemWide, kAXFocusedUIElementAttribute, (CFTypeRef *)&focusedElement) == kAXErrorSuccess && focusedElement) {
+                if (PointInsideElementFrame(focusedElement, cursorPos)) {
+                    cursorType = CursorTypeFromAccessibilityElement(focusedElement, cursorPos);
+                }
+                CFRelease(focusedElement);
+            }
         }
+
+        CFRelease(systemWide);
+        return cursorType;
     }
 }
 
@@ -569,12 +594,10 @@ NSString* getCursorType() {
         if (axCursorType && ![axCursorType isEqualToString:@"default"]) {
             finalType = axCursorType;
         } else if (systemCursorType && [systemCursorType length] > 0) {
-            if ([systemCursorType isEqualToString:@"pointer"] &&
-                (!axCursorType || [axCursorType isEqualToString:@"default"])) {
-                finalType = @"default";
-            } else {
-                finalType = systemCursorType;
-            }
+            // Prefer the system cursor when accessibility reports a generic value.
+            finalType = systemCursorType;
+        } else if (axCursorType && [axCursorType length] > 0) {
+            finalType = axCursorType;
         } else {
             finalType = @"default";
         }
@@ -629,17 +652,8 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         
         CGPoint rawLocation = CGEventGetLocation(event);
         
-        // Apply DPR scaling correction for Retina displays
-        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
+        // Coordinates are already in logical space; no additional scaling needed here.
         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
@@ -702,18 +716,9 @@ void cursorTimerCallback() {
             CFRelease(event);
         }
         
-        // Apply DPR scaling correction for Retina displays
-        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
+        // Coordinates are already in logical space; no additional scaling needed here.
         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
@@ -1042,16 +1047,8 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
         // Get display scaling information
         NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
         CGPoint logicalLocation = rawLocation;
-        
-        if (scalingInfo) {
-            CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
-            NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
-            
-            // CGEventGetLocation returns LOGICAL coordinates (correct for JS layer)
-            // Keep logical coordinates - transformation happens in JS layer
-            logicalLocation = rawLocation;
-        }
-        
+        // CGEventGetLocation already returns logical coordinates; additional scaling happens in JS layer.
+
         NSString *cursorType = getCursorType();
         
         // Mouse button state'ini kontrol et