node-mac-recorder 2.20.3 → 2.20.5

package/package.json

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

package/src/cursor_tracker.mm

@@ -53,37 +53,61 @@ static NSString* CopyAndReleaseCFString(CFStringRef value) {
     return result;
 }
 
-static BOOL pointInsideElementFrame(AXUIElementRef element, CGPoint point) {
-    if (!element) {
+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;
+}
 
-    AXValueRef positionValue = NULL;
-    AXValueRef sizeValue = NULL;
+static NSString* CopyAttributeString(AXUIElementRef element, CFStringRef attribute) {
+    if (!element || !attribute) {
+        return nil;
+    }
 
-    AXError positionError = AXUIElementCopyAttributeValue(element, kAXPositionAttribute, (CFTypeRef *)&positionValue);
-    AXError sizeError = AXUIElementCopyAttributeValue(element, kAXSizeAttribute, (CFTypeRef *)&sizeValue);
+    CFStringRef value = NULL;
+    AXError error = AXUIElementCopyAttributeValue(element, attribute, (CFTypeRef *)&value);
+    if (error == kAXErrorSuccess && value) {
+        return CopyAndReleaseCFString(value);
+    }
 
-    if (positionError != kAXErrorSuccess || sizeError != kAXErrorSuccess || !positionValue || !sizeValue) {
-        if (positionValue) CFRelease(positionValue);
-        if (sizeValue) CFRelease(sizeValue);
+    if (value) {
+        CFRelease(value);
+    }
+    return nil;
+}
+
+static BOOL CopyAttributeBoolean(AXUIElementRef element, CFStringRef attribute, BOOL *outValue) {
+    if (!element || !attribute || !outValue) {
         return NO;
     }
 
-    CGPoint elementOrigin = CGPointZero;
-    CGSize elementSize = CGSizeZero;
-    AXValueGetValue(positionValue, kAXValueTypeCGPoint, &elementOrigin);
-    AXValueGetValue(sizeValue, kAXValueTypeCGSize, &elementSize);
+    CFTypeRef rawValue = NULL;
+    AXError error = AXUIElementCopyAttributeValue(element, attribute, &rawValue);
+    if (error != kAXErrorSuccess || !rawValue) {
+        if (rawValue) {
+            CFRelease(rawValue);
+        }
+        return NO;
+    }
 
-    CFRelease(positionValue);
-    CFRelease(sizeValue);
+    BOOL result = NO;
+    if (CFGetTypeID(rawValue) == CFBooleanGetTypeID()) {
+        result = CFBooleanGetValue((CFBooleanRef)rawValue);
+    }
 
-    CGRect frame = CGRectMake(elementOrigin.x, elementOrigin.y, elementSize.width, elementSize.height);
-    return CGRectContainsPoint(frame, point);
+    CFRelease(rawValue);
+    *outValue = result;
+    return YES;
 }
 
-static BOOL elementHasAction(AXUIElementRef element, CFStringRef actionName) {
-    if (!element || !actionName) {
+static BOOL ElementHasAction(AXUIElementRef element, CFStringRef action) {
+    if (!element || !action) {
         return NO;
     }
 
@@ -96,144 +120,218 @@ static BOOL elementHasAction(AXUIElementRef element, CFStringRef actionName) {
     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) {
+        CFStringRef candidate = (CFStringRef)CFArrayGetValueAtIndex(actions, i);
+        if (CFStringCompare(candidate, action, 0) == kCFCompareEqualTo) {
             hasAction = YES;
             break;
         }
     }
-
     CFRelease(actions);
     return hasAction;
 }
 
-static BOOL elementIsClickable(AXUIElementRef element) {
+static BOOL PointInsideElementFrame(AXUIElementRef element, CGPoint point) {
     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;
-        }
+    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;
     }
 
-    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;
-        }
+    CGPoint origin = CGPointZero;
+    CGSize size = CGSizeZero;
+    AXValueGetValue(positionValue, kAXValueTypeCGPoint, &origin);
+    AXValueGetValue(sizeValue, kAXValueTypeCGSize, &size);
+
+    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);
+
+    if (positionError != kAXErrorSuccess || sizeError != kAXErrorSuccess || !positionValue || !sizeValue) {
+        if (positionValue) CFRelease(positionValue);
+        if (sizeValue) CFRelease(sizeValue);
+        return nil;
     }
 
-    if (elementHasAction(element, kAXPressAction) ||
-        elementHasAction(element, kAXShowMenuAction) ||
-        elementHasAction(element, CFSTR("AXConfirm"))) {
-        return YES;
+    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;
     }
 
-    CFTypeRef urlValue = NULL;
-    if (AXUIElementCopyAttributeValue(element, kAXURLAttribute, &urlValue) == kAXErrorSuccess && urlValue) {
-        CFRelease(urlValue);
-        return YES;
+    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 (urlValue) {
-        CFRelease(urlValue);
-        urlValue = NULL;
+    if ((nearRight && nearTop) || (nearLeft && nearBottom)) {
+        return @"nesw-resize";
     }
-
-    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 (nearLeft || nearRight) {
+        return @"col-resize";
     }
-    if (isEnabled) {
-        CFRelease(isEnabled);
-        isEnabled = NULL;
+    if (nearTop || nearBottom) {
+        return @"ns-resize";
     }
 
-    return NO;
+    return nil;
 }
 
-static BOOL elementSupportsText(AXUIElementRef element) {
+static NSString* CursorTypeFromAccessibilityElement(AXUIElementRef element, CGPoint cursorPos) {
     if (!element) {
-        return NO;
+        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 supportsText = NO;
+    BOOL supportsSelection = NO;
+    if (CopyAttributeBoolean(element, CFSTR("AXSupportsTextSelection"), &supportsSelection) && supportsSelection) {
+        return @"text";
+    }
 
-    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;
+    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);
     }
 
-    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;
+    // Leave progress/help to system cursor; don't force via AX
+
+    if ([role isEqualToString:@"AXSplitter"]) {
+        NSString *orientation = CopyAttributeString(element, CFSTR("AXOrientation"));
+        if ([orientation isEqualToString:@"AXHorizontalOrientation"]) {
+            return @"ns-resize";
+        }
+        if ([orientation isEqualToString:@"AXVerticalOrientation"]) {
+            return @"col-resize";
         }
     }
 
-    CFStringRef roleDescriptionRef = NULL;
-    if (!supportsText && AXUIElementCopyAttributeValue(element, kAXRoleDescriptionAttribute, (CFTypeRef *)&roleDescriptionRef) == kAXErrorSuccess && roleDescriptionRef) {
-        NSString *roleDescription = CopyAndReleaseCFString(roleDescriptionRef);
+    if ([role isEqualToString:@"AXWindow"]) {
+        NSString *windowCursor = CursorTypeForWindowBorder(element, cursorPos);
+        if (windowCursor) {
+            return windowCursor;
+        }
+    }
+
+    // Pointer (hand) only for actual links; buttons remain default arrow on macOS
+    if (StringEqualsAny(role, @[@"AXLink"])) {
+        return @"pointer";
+    }
+    if (StringEqualsAny(subrole, @[@"AXLink"])) {
+        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:@"code"] ||
             [lower containsString:@"document"]) {
-            supportsText = YES;
+            return @"text";
         }
     }
 
-    CFBooleanRef editable = NULL;
-    if (!supportsText && AXUIElementCopyAttributeValue(element, CFSTR("AXEditable"), (CFTypeRef *)&editable) == kAXErrorSuccess && editable) {
-        supportsText = CFBooleanGetValue(editable);
-        CFRelease(editable);
+    // Actions alone do not imply pointer hand on macOS; ignore
+
+    CFTypeRef urlValue = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXURLAttribute, &urlValue) == kAXErrorSuccess && urlValue) {
+        CFRelease(urlValue);
+        return @"pointer";
+    }
+    if (urlValue) {
+        CFRelease(urlValue);
     }
 
-    CFBooleanRef supportsSelection = NULL;
-    if (!supportsText && AXUIElementCopyAttributeValue(element, CFSTR("AXSupportsTextSelection"), (CFTypeRef *)&supportsSelection) == kAXErrorSuccess && supportsSelection) {
-        supportsText = CFBooleanGetValue(supportsSelection);
-        CFRelease(supportsSelection);
+    // Grab/open-hand often comes from system cursor; avoid forcing via AX
+
+    // Zoom is rare; prefer system cursor unless explicitly needed
+    
+    return nil;
+}
+
+static AXUIElementRef CopyParent(AXUIElementRef element) {
+    if (!element) return NULL;
+    AXUIElementRef parent = NULL;
+    if (AXUIElementCopyAttributeValue(element, kAXParentAttribute, (CFTypeRef *)&parent) == kAXErrorSuccess && parent) {
+        return parent; // retained
     }
+    if (parent) CFRelease(parent);
+    return NULL;
+}
 
-    CFTypeRef valueAttribute = NULL;
-    if (!supportsText && AXUIElementCopyAttributeValue(element, kAXValueAttribute, &valueAttribute) == kAXErrorSuccess && valueAttribute) {
-        CFTypeID typeId = CFGetTypeID(valueAttribute);
-        if (typeId == CFAttributedStringGetTypeID() || typeId == CFStringGetTypeID()) {
-            supportsText = YES;
+static NSString* CursorTypeFromElementOrAncestors(AXUIElementRef element, CGPoint cursorPos, int maxDepth) {
+    AXUIElementRef current = element;
+    int depth = 0;
+    while (current && depth < maxDepth) {
+        NSString *t = CursorTypeFromAccessibilityElement(current, cursorPos);
+        if (t && [t length] > 0) {
+            return t;
         }
-        CFRelease(valueAttribute);
+        AXUIElementRef parent = CopyParent(current);
+        if (current != element) CFRelease(current);
+        current = parent;
+        depth++;
     }
-
-    return supportsText;
+    if (current && current != element) CFRelease(current);
+    return nil;
 }
 
 // Mouse button state tracking
@@ -244,333 +342,45 @@ static NSString *g_lastEventType = @"move";
 // 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
-
-            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
-            AXUIElementRef elementAtPosition = NULL;
-            AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
-
-            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) {
-                    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";
-                }
-                // 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";
-                }
-
-                // 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
-                }
+        AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+        if (!systemWide) {
+            return nil;
+        }
 
-                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";
-                        }
-                    }
-                }
+        NSString *cursorType = nil;
 
-                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";
-                }
+        AXUIElementRef elementAtPosition = NULL;
+        AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+        if (error == kAXErrorSuccess && elementAtPosition) {
+            cursorType = CursorTypeFromElementOrAncestors(elementAtPosition, cursorPos, 6);
+            CFRelease(elementAtPosition);
+        }
 
-                CFTypeRef valueAttribute = NULL;
-                if (AXUIElementCopyAttributeValue(elementAtPosition, kAXValueAttribute, &valueAttribute) == kAXErrorSuccess && valueAttribute) {
-                    CFTypeID typeId = CFGetTypeID(valueAttribute);
-                    if (typeId == CFAttributedStringGetTypeID() ||
-                        typeId == CFStringGetTypeID()) {
-                        cursorType = @"text";
-                    }
-                    CFRelease(valueAttribute);
+        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 = CursorTypeFromElementOrAncestors(hitElement, cursorPos, 6);
+                    CFRelease(hitElement);
                 }
-
             }
+        }
 
-            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";
-                            }
-                            CFRelease(deepElement);
-                        }
-                    }
-                }
-
-                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";
-                        }
-                        CFRelease(focusedElement);
-                    }
+        if (!cursorType) {
+            AXUIElementRef focusedElement = NULL;
+            if (AXUIElementCopyAttributeValue(systemWide, kAXFocusedUIElementAttribute, (CFTypeRef *)&focusedElement) == kAXErrorSuccess && focusedElement) {
+                if (PointInsideElementFrame(focusedElement, cursorPos)) {
+                    cursorType = CursorTypeFromAccessibilityElement(focusedElement, cursorPos);
                 }
-
-                CFRelease(elementAtPosition);
-            }
-            if (systemWide) {
-                CFRelease(systemWide);
+                CFRelease(focusedElement);
             }
-
-            // Son güvence - eğer cursorType hala nil veya geçersizse default'a çevir
-            if (!cursorType || [cursorType length] == 0) {
-                cursorType = @"default";
-            }
-
-            NSLog(@"🎯 AX CURSOR TYPE: %@", cursorType);
-            return cursorType;
-            
-        } @catch (NSException *exception) {
-            NSLog(@"Error in detectCursorTypeUsingAccessibility: %@", exception);
-            return @"default";
         }
+
+        CFRelease(systemWide);
+        return cursorType;
     }
 }
 
@@ -852,6 +662,10 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
         NSTimeInterval unixTimeMs = [currentDate timeIntervalSince1970] * 1000; // unix timestamp in milliseconds
         NSString *cursorType = getCursorType();
+        // Debug fields: capture raw AX and system cursor types
+        NSString *axTypeDbg = detectCursorTypeUsingAccessibility(location);
+        NSString *sysTypeDbg = detectSystemCursorType();
+        // (already captured above)
         NSString *eventType = @"move";
         
         // Event tipini belirle
@@ -884,7 +698,9 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             @"timestamp": @(timestamp),
             @"unixTimeMs": @(unixTimeMs),
             @"cursorType": cursorType,
-            @"type": eventType
+            @"type": eventType,
+            @"axCursorType": axTypeDbg ? axTypeDbg : @"",
+            @"systemCursorType": sysTypeDbg ? sysTypeDbg : @""
         };
         
         // Direkt dosyaya yaz
@@ -917,6 +733,9 @@ void cursorTimerCallback() {
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
         NSTimeInterval unixTimeMs = [currentDate timeIntervalSince1970] * 1000; // unix timestamp in milliseconds
         NSString *cursorType = getCursorType();
+        // Debug fields: capture raw AX and system cursor types
+        NSString *axTypeDbg = detectCursorTypeUsingAccessibility(location);
+        NSString *sysTypeDbg = detectSystemCursorType();
         
         // Cursor data oluştur
         NSDictionary *cursorInfo = @{
@@ -925,7 +744,9 @@ void cursorTimerCallback() {
             @"timestamp": @(timestamp),
             @"unixTimeMs": @(unixTimeMs),
             @"cursorType": cursorType,
-            @"type": @"move"
+            @"type": @"move",
+            @"axCursorType": axTypeDbg ? axTypeDbg : @"",
+            @"systemCursorType": sysTypeDbg ? sysTypeDbg : @""
         };
         
         // Direkt dosyaya yaz