node-mac-recorder 2.20.1 → 2.20.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.20.1",
+	"version": "2.20.3",
 	"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;
@@ -40,16 +44,203 @@ static CursorTimerTarget *g_timerTarget = nil;
 static NSString *g_lastDetectedCursorType = nil;
 static int g_cursorTypeCounter = 0;
 
+static NSString* CopyAndReleaseCFString(CFStringRef value) {
+    if (!value) {
+        return nil;
+    }
+    NSString *result = [NSString stringWithString:(NSString *)value];
+    CFRelease(value);
+    return result;
+}
+
+static BOOL pointInsideElementFrame(AXUIElementRef element, CGPoint point) {
+    if (!element) {
+        return NO;
+    }
+
+    AXValueRef positionValue = NULL;
+    AXValueRef sizeValue = NULL;
+
+    AXError positionError = AXUIElementCopyAttributeValue(element, kAXPositionAttribute, (CFTypeRef *)&positionValue);
+    AXError sizeError = AXUIElementCopyAttributeValue(element, kAXSizeAttribute, (CFTypeRef *)&sizeValue);
+
+    if (positionError != kAXErrorSuccess || sizeError != kAXErrorSuccess || !positionValue || !sizeValue) {
+        if (positionValue) CFRelease(positionValue);
+        if (sizeValue) CFRelease(sizeValue);
+        return NO;
+    }
+
+    CGPoint elementOrigin = CGPointZero;
+    CGSize elementSize = CGSizeZero;
+    AXValueGetValue(positionValue, kAXValueTypeCGPoint, &elementOrigin);
+    AXValueGetValue(sizeValue, kAXValueTypeCGSize, &elementSize);
+
+    CFRelease(positionValue);
+    CFRelease(sizeValue);
+
+    CGRect frame = CGRectMake(elementOrigin.x, elementOrigin.y, elementSize.width, elementSize.height);
+    return CGRectContainsPoint(frame, point);
+}
+
+static BOOL elementHasAction(AXUIElementRef element, CFStringRef actionName) {
+    if (!element || !actionName) {
+        return NO;
+    }
+
+    CFArrayRef actions = NULL;
+    AXError error = AXUIElementCopyActionNames(element, &actions);
+    if (error != kAXErrorSuccess || !actions) {
+        return NO;
+    }
+
+    BOOL hasAction = NO;
+    CFIndex count = CFArrayGetCount(actions);
+    for (CFIndex i = 0; i < count; i++) {
+        CFStringRef action = (CFStringRef)CFArrayGetValueAtIndex(actions, i);
+        if (CFStringCompare(action, actionName, 0) == kCFCompareEqualTo) {
+            hasAction = YES;
+            break;
+        }
+    }
+
+    CFRelease(actions);
+    return hasAction;
+}
+
+static BOOL elementIsClickable(AXUIElementRef element) {
+    if (!element) {
+        return NO;
+    }
+
+    CFStringRef roleRef = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXRoleAttribute, (CFTypeRef *)&roleRef) == kAXErrorSuccess && roleRef) {
+        NSString *role = CopyAndReleaseCFString(roleRef);
+        if ([role isEqualToString:@"AXButton"] ||
+            [role isEqualToString:@"AXLink"] ||
+            [role isEqualToString:@"AXMenuItem"] ||
+            [role isEqualToString:@"AXTab"] ||
+            [role isEqualToString:@"AXRadioButton"] ||
+            [role isEqualToString:@"AXCheckBox"] ||
+            [role isEqualToString:@"AXPopUpButton"]) {
+            return YES;
+        }
+    }
+
+    CFStringRef subroleRef = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXSubroleAttribute, (CFTypeRef *)&subroleRef) == kAXErrorSuccess && subroleRef) {
+        NSString *subrole = CopyAndReleaseCFString(subroleRef);
+        if ([subrole isEqualToString:@"AXLink"] ||
+            [subrole isEqualToString:@"AXFileDrop"] ||
+            [subrole isEqualToString:@"AXDropTarget"] ||
+            [subrole isEqualToString:@"AXToolbarButton"]) {
+            return YES;
+        }
+    }
+
+    if (elementHasAction(element, kAXPressAction) ||
+        elementHasAction(element, kAXShowMenuAction) ||
+        elementHasAction(element, CFSTR("AXConfirm"))) {
+        return YES;
+    }
+
+    CFTypeRef urlValue = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXURLAttribute, &urlValue) == kAXErrorSuccess && urlValue) {
+        CFRelease(urlValue);
+        return YES;
+    }
+    if (urlValue) {
+        CFRelease(urlValue);
+        urlValue = NULL;
+    }
+
+    CFBooleanRef isEnabled = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXEnabledAttribute, (CFTypeRef *)&isEnabled) == kAXErrorSuccess &&
+        isEnabled && CFBooleanGetValue(isEnabled)) {
+        CFRelease(isEnabled);
+        isEnabled = NULL;
+        if (elementHasAction(element, CFSTR("AXShowMenu")) || elementHasAction(element, CFSTR("AXDecrement")) || elementHasAction(element, CFSTR("AXIncrement"))) {
+            return YES;
+        }
+    }
+    if (isEnabled) {
+        CFRelease(isEnabled);
+        isEnabled = NULL;
+    }
+
+    return NO;
+}
+
+static BOOL elementSupportsText(AXUIElementRef element) {
+    if (!element) {
+        return NO;
+    }
+
+    BOOL supportsText = NO;
+
+    CFStringRef roleRef = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXRoleAttribute, (CFTypeRef *)&roleRef) == kAXErrorSuccess && roleRef) {
+        NSString *role = CopyAndReleaseCFString(roleRef);
+        if ([role isEqualToString:@"AXTextField"] ||
+            [role isEqualToString:@"AXTextArea"] ||
+            [role isEqualToString:@"AXSearchField"] ||
+            [role isEqualToString:@"AXStaticText"] ||
+            [role isEqualToString:@"AXDocument"] ||
+            [role isEqualToString:@"AXWebArea"]) {
+            supportsText = YES;
+        }
+    }
+
+    CFStringRef subroleRef = NULL;
+    if (!supportsText && AXUIElementCopyAttributeValue(element, kAXSubroleAttribute, (CFTypeRef *)&subroleRef) == kAXErrorSuccess && subroleRef) {
+        NSString *subrole = CopyAndReleaseCFString(subroleRef);
+        if ([subrole isEqualToString:@"AXSecureTextField"] ||
+            [subrole isEqualToString:@"AXTextAttachment"] ||
+            [subrole isEqualToString:@"AXTextField"]) {
+            supportsText = YES;
+        }
+    }
+
+    CFStringRef roleDescriptionRef = NULL;
+    if (!supportsText && AXUIElementCopyAttributeValue(element, kAXRoleDescriptionAttribute, (CFTypeRef *)&roleDescriptionRef) == kAXErrorSuccess && roleDescriptionRef) {
+        NSString *roleDescription = CopyAndReleaseCFString(roleDescriptionRef);
+        NSString *lower = [roleDescription lowercaseString];
+        if ([lower containsString:@"text"] ||
+            [lower containsString:@"editor"] ||
+            [lower containsString:@"code"] ||
+            [lower containsString:@"document"]) {
+            supportsText = YES;
+        }
+    }
+
+    CFBooleanRef editable = NULL;
+    if (!supportsText && AXUIElementCopyAttributeValue(element, CFSTR("AXEditable"), (CFTypeRef *)&editable) == kAXErrorSuccess && editable) {
+        supportsText = CFBooleanGetValue(editable);
+        CFRelease(editable);
+    }
+
+    CFBooleanRef supportsSelection = NULL;
+    if (!supportsText && AXUIElementCopyAttributeValue(element, CFSTR("AXSupportsTextSelection"), (CFTypeRef *)&supportsSelection) == kAXErrorSuccess && supportsSelection) {
+        supportsText = CFBooleanGetValue(supportsSelection);
+        CFRelease(supportsSelection);
+    }
+
+    CFTypeRef valueAttribute = NULL;
+    if (!supportsText && AXUIElementCopyAttributeValue(element, kAXValueAttribute, &valueAttribute) == kAXErrorSuccess && valueAttribute) {
+        CFTypeID typeId = CFGetTypeID(valueAttribute);
+        if (typeId == CFAttributedStringGetTypeID() || typeId == CFStringGetTypeID()) {
+            supportsText = YES;
+        }
+        CFRelease(valueAttribute);
+    }
+
+    return supportsText;
+}
+
 // Mouse button state tracking
 static bool g_leftMouseDown = false;
 static bool g_rightMouseDown = false;
 static NSString *g_lastEventType = @"move";
 
-// Event tap callback
-static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *userInfo) {
-    return event;
-}
-
 // Accessibility tabanlı cursor tip tespiti
 static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
     @autoreleasepool {
@@ -64,223 +255,304 @@ static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
             NSString *cursorType = @"default"; // Default fallback
 
             if (error == kAXErrorSuccess && elementAtPosition) {
+                NSString *elementRole = nil;
                 CFStringRef role = NULL;
                 error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
-
                 if (error == kAXErrorSuccess && role) {
-                    NSString *elementRole = (__bridge_transfer NSString*)role;
+                    elementRole = CopyAndReleaseCFString(role);
+                }
+
+                if (elementRole) {
                     NSLog(@"🎯 ELEMENT ROLE: %@", elementRole);
+                }
 
-                    // 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";
+                // 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";
                     }
-                    // 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";
+                }
+                // 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";
+                            cursorType = @"default"; // Bilinmeyen orientation
                         }
+                    } else {
+                        cursorType = @"default"; // Orientation alınamazsa 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";
+                }
+                // 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";
                     }
-                    // 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"]) {
-                                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
+                }
+                // 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"; // Orientation alınamazsa default
+                            cursorType = @"default";
                         }
+                    } else {
+                        cursorType = @"default";
                     }
-                    // SCROLL CURSORS - hep default olsun, all-scroll görünmesin
-                    else if ([elementRole isEqualToString:@"AXScrollBar"]) {
-                        cursorType = @"default"; // ScrollBar'lar için de default
+                }
+                // HER DURUM İÇİN DEFAULT FALLBACK
+                else {
+                    // Bilinmeyen elementler için her zaman default
+                    cursorType = @"default";
+                }
+
+                // 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";
                     }
-                    // AXScrollArea - hep default
-                    else if ([elementRole isEqualToString:@"AXScrollArea"]) {
-                        cursorType = @"default"; // ScrollArea her zaman default
+                    // Alias/shortcut subroles
+                    else if ([elementSubrole isEqualToString:@"AXAlias"] ||
+                             [elementSubrole isEqualToString:@"AXShortcut"]) {
+                        cursorType = @"alias";
                     }
-                    // CROSSHAIR CURSORS (drawing/selection tools)
-                    else if ([elementRole isEqualToString:@"AXCanvas"] ||
-                             [elementRole isEqualToString:@"AXDrawingArea"]) {
-                        cursorType = @"crosshair";
+                    // Grabbing state (being dragged) - sadece gerçek drag sırasında
+                    else if ([elementSubrole isEqualToString:@"AXDragging"] ||
+                             [elementSubrole isEqualToString:@"AXMoving"]) {
+                        cursorType = @"grabbing";
                     }
-                    // ZOOM CURSORS (zoom controls)
-                    else if ([elementRole isEqualToString:@"AXZoomButton"]) {
+                    // Zoom controls - sadece spesifik zoom butonları için
+                    else if ([elementSubrole isEqualToString:@"AXZoomIn"]) {
                         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";
+                    else if ([elementSubrole isEqualToString:@"AXZoomOut"]) {
+                        cursorType = @"zoom-out";
+                    }
+                    // Subrole'dan bir şey bulamazsa role-based cursor'ı koruyoruz
+                }
+
+                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";
                         }
                     }
-                    // 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";
+                }
+
+                CFBooleanRef isEditable = NULL;
+                if (AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXEditable"), (CFTypeRef*)&isEditable) == kAXErrorSuccess &&
+                    isEditable && CFBooleanGetValue(isEditable)) {
+                    cursorType = @"text";
+                }
+
+                CFBooleanRef supportsTextSelection = NULL;
+                if (AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXSupportsTextSelection"), (CFTypeRef*)&supportsTextSelection) == kAXErrorSuccess &&
+                    supportsTextSelection && CFBooleanGetValue(supportsTextSelection)) {
+                    cursorType = @"text";
+                }
+
+                CFTypeRef valueAttribute = NULL;
+                if (AXUIElementCopyAttributeValue(elementAtPosition, kAXValueAttribute, &valueAttribute) == kAXErrorSuccess && valueAttribute) {
+                    CFTypeID typeId = CFGetTypeID(valueAttribute);
+                    if (typeId == CFAttributedStringGetTypeID() ||
+                        typeId == CFStringGetTypeID()) {
+                        cursorType = @"text";
+                    }
+                    CFRelease(valueAttribute);
+                }
+
+            }
+
+            if (elementAtPosition) {
+                if ([cursorType isEqualToString:@"default"] && elementSupportsText(elementAtPosition)) {
+                    cursorType = @"text";
+                }
+
+                if ([cursorType isEqualToString:@"default"] && elementIsClickable(elementAtPosition)) {
+                    cursorType = @"pointer";
+                }
+
+                if ([cursorType isEqualToString:@"default"]) {
+                    AXValueRef pointValue = AXValueCreate(kAXValueTypeCGPoint, &cursorPos);
+                    if (pointValue) {
+                        AXUIElementRef deepElement = NULL;
+                        AXError hitError = AXUIElementCopyParameterizedAttributeValue(systemWide, kAXHitTestParameterizedAttribute, pointValue, (CFTypeRef *)&deepElement);
+                        CFRelease(pointValue);
+                        if (hitError == kAXErrorSuccess && deepElement) {
+                            if (elementSupportsText(deepElement)) {
+                                cursorType = @"text";
+                            } else if (elementIsClickable(deepElement)) {
+                                cursorType = @"pointer";
                             }
-                        } else {
-                            cursorType = @"default";
+                            CFRelease(deepElement);
                         }
                     }
-                    // HER DURUM İÇİN DEFAULT FALLBACK
-                    else {
-                        // Bilinmeyen elementler için her zaman default
-                        cursorType = @"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"]) {
+                if ([cursorType isEqualToString:@"default"]) {
+                    AXUIElementRef focusedElement = NULL;
+                    if (AXUIElementCopyAttributeValue(systemWide, kAXFocusedUIElementAttribute, (CFTypeRef *)&focusedElement) == kAXErrorSuccess && focusedElement) {
+                        if (elementSupportsText(focusedElement) && pointInsideElementFrame(focusedElement, cursorPos)) {
+                            cursorType = @"text";
+                        } else if (elementIsClickable(focusedElement) && pointInsideElementFrame(focusedElement, cursorPos)) {
                             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
+                        CFRelease(focusedElement);
                     }
                 }
 
-            }
-
-            if (elementAtPosition) {
                 CFRelease(elementAtPosition);
             }
             if (systemWide) {
@@ -482,10 +754,6 @@ NSString* getCursorType() {
         g_cursorTypeCounter++;
 
         NSString *systemCursorType = detectSystemCursorType();
-        if (systemCursorType && ![systemCursorType isEqualToString:@"default"]) {
-            NSLog(@"🎯 FINAL CURSOR TYPE: %@", systemCursorType);
-            return systemCursorType;
-        }
 
         NSString *axCursorType = nil;
         BOOL hasCursorPosition = NO;
@@ -520,7 +788,10 @@ NSString* getCursorType() {
         if (axCursorType && ![axCursorType isEqualToString:@"default"]) {
             finalType = axCursorType;
         } else if (systemCursorType && [systemCursorType length] > 0) {
+            // Prefer the system cursor when accessibility reports a generic value.
             finalType = systemCursorType;
+        } else if (axCursorType && [axCursorType length] > 0) {
+            finalType = axCursorType;
         } else {
             finalType = @"default";
         }
@@ -575,17 +846,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
@@ -648,18 +910,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
@@ -988,16 +1241,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