node-mac-recorder 2.22.24 → 2.22.33

package/src/cursor_tracker.mm

@@ -7,8 +7,8 @@
 #import <Accessibility/Accessibility.h>
 #import <dispatch/dispatch.h>
 #import "logging.h"
-#import "text_input_ax_snapshot.h"
 #include <vector>
+#include <cstring>
 #include <math.h>
 
 #ifndef kAXHitTestParameterizedAttribute
@@ -310,6 +310,180 @@ static NSCursor* CursorFromSelector(SEL selector) {
     return func([NSCursor class], selector);
 }
 
+static BOOL CursorEqualsFactoryNamed(NSCursor *cursor, NSString *factoryMethodName) {
+    if (!cursor || !factoryMethodName || [factoryMethodName length] == 0) {
+        return NO;
+    }
+    SEL sel = NSSelectorFromString(factoryMethodName);
+    NSCursor *ref = CursorFromSelector(sel);
+    return ref != nil && cursor == ref;
+}
+
+static uint64_t CursorImagePixelHash(NSImage *image) {
+    if (!image) {
+        return 0;
+    }
+    NSRect imageRect = NSMakeRect(0, 0, [image size].width, [image size].height);
+    CGImageRef cgImage = [image CGImageForProposedRect:&imageRect context:nil hints:nil];
+    if (!cgImage) {
+        for (NSImageRep *rep in [image representations]) {
+            if ([rep isKindOfClass:[NSBitmapImageRep class]]) {
+                cgImage = [(NSBitmapImageRep *)rep CGImage];
+                if (cgImage) {
+                    break;
+                }
+            }
+        }
+    }
+    if (!cgImage) {
+        return 0;
+    }
+    size_t width = CGImageGetWidth(cgImage);
+    size_t height = CGImageGetHeight(cgImage);
+    if (width == 0 || height == 0) {
+        return 0;
+    }
+    size_t bytesPerPixel = 4;
+    size_t bytesPerRow = width * bytesPerPixel;
+    size_t bufferSize = bytesPerRow * height;
+    if (bufferSize == 0) {
+        return 0;
+    }
+    std::vector<unsigned char> buffer(bufferSize);
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    if (!colorSpace) {
+        return 0;
+    }
+    CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Little | (CGBitmapInfo)kCGImageAlphaPremultipliedLast;
+    CGContextRef context = CGBitmapContextCreate(buffer.data(),
+                                                 width,
+                                                 height,
+                                                 8,
+                                                 bytesPerRow,
+                                                 colorSpace,
+                                                 bitmapInfo);
+    CGColorSpaceRelease(colorSpace);
+    if (!context) {
+        return 0;
+    }
+    CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
+    CGContextRelease(context);
+    return FNV1AHash(buffer.data(), buffer.size());
+}
+
+static uint64_t CursorImagePixelHashNormalized32(NSImage *image) {
+    if (!image) {
+        return 0;
+    }
+    const int dim = 32;
+    size_t bytesPerPixel = 4;
+    size_t bytesPerRow = (size_t)dim * bytesPerPixel;
+    std::vector<unsigned char> buffer(bytesPerRow * (size_t)dim);
+    memset(buffer.data(), 0, buffer.size());
+
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    if (!colorSpace) {
+        return 0;
+    }
+    CGContextRef ctx = CGBitmapContextCreate(buffer.data(),
+                                             (size_t)dim,
+                                             (size_t)dim,
+                                             8,
+                                             bytesPerRow,
+                                             colorSpace,
+                                             kCGBitmapByteOrder32Little | (CGBitmapInfo)kCGImageAlphaPremultipliedLast);
+    CGColorSpaceRelease(colorSpace);
+    if (!ctx) {
+        return 0;
+    }
+
+    CGContextClearRect(ctx, CGRectMake(0, 0, dim, dim));
+    NSGraphicsContext *nsgc = [NSGraphicsContext graphicsContextWithCGContext:ctx flipped:YES];
+    [NSGraphicsContext saveGraphicsState];
+    [NSGraphicsContext setCurrentContext:nsgc];
+
+    NSSize sz = [image size];
+    if (sz.width <= 0 || sz.height <= 0) {
+        [NSGraphicsContext restoreGraphicsState];
+        CGContextRelease(ctx);
+        return 0;
+    }
+    CGFloat scale = MIN((CGFloat)dim / sz.width, (CGFloat)dim / sz.height);
+    CGFloat rw = sz.width * scale;
+    CGFloat rh = sz.height * scale;
+    CGFloat ox = ((CGFloat)dim - rw) / 2.0;
+    CGFloat oy = ((CGFloat)dim - rh) / 2.0;
+    [image drawInRect:NSMakeRect(ox, oy, rw, rh)
+             fromRect:NSZeroRect
+            operation:NSCompositingOperationSourceOver
+             fraction:1.0
+       respectFlipped:YES
+                hints:nil];
+
+    [NSGraphicsContext restoreGraphicsState];
+    CGContextRelease(ctx);
+    return FNV1AHash(buffer.data(), buffer.size());
+}
+
+static NSString* DiagonalResizeTypeByVisualMatch(NSCursor *cursor) {
+    if (!cursor) {
+        return nil;
+    }
+    if (CursorEqualsFactoryNamed(cursor, @"resizeNorthWestSouthEastCursor")) {
+        return @"nwse-resize";
+    }
+    if (CursorEqualsFactoryNamed(cursor, @"resizeNorthEastSouthWestCursor")) {
+        return @"nesw-resize";
+    }
+
+    NSImage *curImg = [cursor image];
+    if (!curImg) {
+        return nil;
+    }
+
+    NSData *curTIFF = [curImg TIFFRepresentation];
+    uint64_t curRaw = CursorImagePixelHash(curImg);
+    uint64_t curNorm = CursorImagePixelHashNormalized32(curImg);
+
+    struct DiagonalFactoryEntry {
+        const char *selectorName;
+        const char *type;
+    };
+    static const DiagonalFactoryEntry kDiagonalFactories[] = {
+        { "resizeNorthWestSouthEastCursor", "nwse-resize" },
+        { "resizeNorthEastSouthWestCursor", "nesw-resize" },
+    };
+
+    for (size_t i = 0; i < sizeof(kDiagonalFactories) / sizeof(kDiagonalFactories[0]); i++) {
+        NSString *selStr = [NSString stringWithUTF8String:kDiagonalFactories[i].selectorName];
+        SEL sel = NSSelectorFromString(selStr);
+        if (![NSCursor respondsToSelector:sel]) {
+            continue;
+        }
+        NSCursor *ref = CursorFromSelector(sel);
+        if (!ref) {
+            continue;
+        }
+        NSImage *refImg = [ref image];
+        if (!refImg) {
+            continue;
+        }
+        NSData *refTIFF = [refImg TIFFRepresentation];
+        if (curTIFF && refTIFF && [curTIFF isEqualToData:refTIFF]) {
+            return [NSString stringWithUTF8String:kDiagonalFactories[i].type];
+        }
+        uint64_t refRaw = CursorImagePixelHash(refImg);
+        if (curRaw != 0 && curRaw == refRaw) {
+            return [NSString stringWithUTF8String:kDiagonalFactories[i].type];
+        }
+        uint64_t refNorm = CursorImagePixelHashNormalized32(refImg);
+        if (curNorm != 0 && curNorm == refNorm) {
+            return [NSString stringWithUTF8String:kDiagonalFactories[i].type];
+        }
+    }
+    return nil;
+}
+
 static void AddStandardCursorFingerprint(NSCursor *cursor, NSString *cursorType) {
     if (!cursor || !cursorType) {
         return;
@@ -360,7 +534,7 @@ static void InitializeCursorFingerprintMap(void) {
             AddCursorIfAvailable(@selector(dragCopyCursor), @"copy");
             AddCursorIfAvailable(@selector(dragLinkCursor), @"alias");
             AddCursorIfAvailable(@selector(resizeLeftRightCursor), @"col-resize");
-            AddCursorIfAvailable(@selector(resizeUpDownCursor), @"row-resize");
+            AddCursorIfAvailable(@selector(resizeUpDownCursor), @"ns-resize");
             AddCursorIfAvailableByName(@"resizeLeftCursor", @"col-resize");
             AddCursorIfAvailableByName(@"resizeRightCursor", @"col-resize");
             AddCursorIfAvailableByName(@"resizeUpCursor", @"ns-resize");
@@ -503,21 +677,26 @@ static BOOL ShouldEmitCursorEvent(CGPoint location, NSString *cursorType, NSStri
     BOOL moved = fabs(location.x - g_lastCursorLocation.x) >= movementThreshold ||
                  fabs(location.y - g_lastCursorLocation.y) >= movementThreshold;
     BOOL eventChanged = !StringsEqual(eventType, g_lastCursorEventType);
-    BOOL isMoveEvent = StringsEqual(eventType, @"move") || StringsEqual(eventType, @"drag");
+    BOOL isDragEvent = StringsEqual(eventType, @"drag") || StringsEqual(eventType, @"rightdrag");
+    BOOL isMoveOnly = StringsEqual(eventType, @"move");
     BOOL isClickEvent = StringsEqual(eventType, @"mousedown") ||
                         StringsEqual(eventType, @"mouseup") ||
                         StringsEqual(eventType, @"rightmousedown") ||
                         StringsEqual(eventType, @"rightmouseup");
 
-    if (isMoveEvent) {
-        return moved;
+    if (isDragEvent) {
+        return YES;
+    }
+
+    if (isMoveOnly) {
+        BOOL cursorChanged = !StringsEqual(cursorType, g_lastCursorType);
+        return moved || cursorChanged;
     }
 
     if (isClickEvent) {
         return eventChanged || moved;
     }
 
-    // Fallback: only emit when something actually changed
     BOOL cursorChanged = !StringsEqual(cursorType, g_lastCursorType);
     return moved || cursorChanged || eventChanged;
 }
@@ -671,7 +850,10 @@ static NSString* CursorTypeForWindowBorder(AXUIElementRef element, CGPoint curso
     CFRelease(positionValue);
     CFRelease(sizeValue);
 
-    CGFloat edge = 4.0;
+    // Köşe: köşe noktasına uzaklık (kutu sınırında col ↔ diagonal sıçramasını azaltır).
+    const CGFloat cornerRadius = 9.0;
+    const CGFloat edgeInset = 12.0;
+
     CGFloat x = cursorPos.x - windowOrigin.x;
     CGFloat y = cursorPos.y - windowOrigin.y;
     CGFloat w = windowSize.width;
@@ -681,17 +863,44 @@ static NSString* CursorTypeForWindowBorder(AXUIElementRef element, CGPoint curso
         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 (w < cornerRadius * 2.1 || h < cornerRadius * 2.1) {
+        CGFloat edge = edgeInset;
+        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;
+    }
+
+    CGFloat dBottomLeft = hypot(x, y);
+    CGFloat dTopRight = hypot(w - x, h - y);
+    CGFloat dBottomRight = hypot(w - x, y);
+    CGFloat dTopLeft = hypot(x, h - y);
 
-    if ((nearLeft && nearTop) || (nearRight && nearBottom)) {
+    if (dBottomLeft <= cornerRadius || dTopRight <= cornerRadius) {
         return @"nwse-resize";
     }
-    if ((nearRight && nearTop) || (nearLeft && nearBottom)) {
+    if (dBottomRight <= cornerRadius || dTopLeft <= cornerRadius) {
         return @"nesw-resize";
     }
+
+    BOOL nearLeft = (x >= 0 && x <= edgeInset);
+    BOOL nearRight = (x >= w - edgeInset && x <= w);
+    BOOL nearTop = (y >= 0 && y <= edgeInset);
+    BOOL nearBottom = (y >= h - edgeInset && y <= h);
+
     if (nearLeft || nearRight) {
         return @"col-resize";
     }
@@ -702,6 +911,42 @@ static NSString* CursorTypeForWindowBorder(AXUIElementRef element, CGPoint curso
     return nil;
 }
 
+static NSString* ResizeTypeFromWindowUnderCursor(CGPoint cursorPos) {
+    @autoreleasepool {
+        AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+        if (!systemWide) {
+            return nil;
+        }
+        AXUIElementRef hit = NULL;
+        AXError err = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &hit);
+        CFRelease(systemWide);
+        if (err != kAXErrorSuccess || !hit) {
+            if (hit) {
+                CFRelease(hit);
+            }
+            return nil;
+        }
+
+        AXUIElementRef node = hit;
+        for (int depth = 0; depth < 24 && node; depth++) {
+            NSString *role = CopyAttributeString(node, kAXRoleAttribute);
+            if ([role isEqualToString:@"AXWindow"]) {
+                NSString *borderType = CursorTypeForWindowBorder(node, cursorPos);
+                CFRelease(node);
+                return borderType;
+            }
+            AXUIElementRef parent = NULL;
+            AXError perr = AXUIElementCopyAttributeValue(node, kAXParentAttribute, (CFTypeRef *)&parent);
+            CFRelease(node);
+            node = NULL;
+            if (perr == kAXErrorSuccess && parent) {
+                node = parent;
+            }
+        }
+        return nil;
+    }
+}
+
 static NSString* CursorTypeFromAccessibilityElement(AXUIElementRef element, CGPoint cursorPos) {
     if (!element) {
         return nil;
@@ -815,10 +1060,6 @@ static bool g_leftMouseDown = false;
 static bool g_rightMouseDown = false;
 static NSString *g_lastEventType = @"move";
 
-// Text input (keyboard) tracking state
-static NSTimeInterval g_lastTextInputEmitTime = 0; // Throttle: son textInput event zamanı
-static const NSTimeInterval TEXT_INPUT_THROTTLE_MS = 50; // Min 50ms aralık (20 FPS)
-
 // Accessibility tabanlı cursor tip tespiti
 static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
     @autoreleasepool {
@@ -942,6 +1183,14 @@ static NSString* cursorTypeFromCursorName(NSString *value) {
         return @"zoom-in";
     }
 
+    // CGS / tema kısa diagonal tokenları (nwse / nesw)
+    if ([normalized containsString:@"nesw"]) {
+        return @"nesw-resize";
+    }
+    if ([normalized containsString:@"nwse"]) {
+        return @"nwse-resize";
+    }
+
     // All-scroll pattern (move in all directions)
     if ([normalized containsString:@"all-scroll"] ||
         [normalized containsString:@"allscroll"] ||
@@ -1388,6 +1637,13 @@ static NSString* cursorTypeFromImageSignature(NSImage *image, NSPoint hotspot, N
     CGFloat relativeX = width > 0 ? hotspot.x / width : 0;
     CGFloat relativeY = height > 0 ? hotspot.y / height : 0;
 
+    if (cursor) {
+        NSString *diag = DiagonalResizeTypeByVisualMatch(cursor);
+        if (diag) {
+            return diag;
+        }
+    }
+
     // Tolerance for floating point comparison
     CGFloat tolerance = 0.05;
     CGFloat tightTolerance = 0.02; // For precise hotspot matching
@@ -1427,29 +1683,35 @@ static NSString* cursorTypeFromImageSignature(NSImage *image, NSPoint hotspot, N
     // Distinguished by pointer equality
     if (approx(width, 32) && approx(height, 32) && approx(relativeY, 0.531)) {
         if (cursor) {
-            if (cursor == [NSCursor closedHandCursor]) {
+            if ([NSCursor respondsToSelector:@selector(closedHandCursor)] &&
+                cursor == [NSCursor closedHandCursor]) {
                 return @"grabbing";
             }
-            if (cursor == [NSCursor openHandCursor]) {
+            if ([NSCursor respondsToSelector:@selector(openHandCursor)] &&
+                cursor == [NSCursor openHandCursor]) {
                 return @"grab";
             }
         }
         return @"grab"; // Default to grab if can't distinguish
     }
 
-    // 24x24 cursors: crosshair vs move/all-scroll
-    // Distinguished by precise hotspot position
+    // 24x24: köşe diagonal resize ile crosshair/move aynı boyutta — önce diagonal fabrika
     if (approx(width, 24) && approx(height, 24)) {
+        if (cursor) {
+            NSString *diag = DiagonalResizeTypeByVisualMatch(cursor);
+            if (diag) {
+                return diag;
+            }
+        }
         // crosshair: hotspot rel=(0.458, 0.458)
         if (approxTight(relativeX, 0.458) && approxTight(relativeY, 0.458)) {
             return @"crosshair";
         }
         // move/all-scroll: hotspot rel=(0.5, 0.5)
         if (approxTight(relativeX, 0.5) && approxTight(relativeY, 0.5)) {
-            return @"move"; // or all-scroll, they're identical
+            return @"move";
         }
-        // Fallback for 24x24
-        return @"crosshair";
+        return nil;
     }
 
     // help/cell: 18x18, ratio=1.0, hotspot rel=(0.5, 0.5)
@@ -1510,7 +1772,29 @@ static NSString* cursorTypeFromImageSignature(NSImage *image, NSPoint hotspot, N
 
     // ne-resize/nw-resize/se-resize/sw-resize/nesw-resize/nwse-resize: 22x22, ratio=1.0, hotspot rel=(0.5, 0.5)
     if (approx(width, 22) && approx(height, 22)) {
-        return @"nwse-resize"; // Default to nwse-resize for all diagonal cursors
+        if (cursor) {
+            NSString *diag = DiagonalResizeTypeByVisualMatch(cursor);
+            if (diag) {
+                return diag;
+            }
+            if ([NSCursor respondsToSelector:@selector(resizeUpCursor)] &&
+                cursor == [NSCursor resizeUpCursor]) {
+                return @"n-resize";
+            }
+            if ([NSCursor respondsToSelector:@selector(resizeDownCursor)] &&
+                cursor == [NSCursor resizeDownCursor]) {
+                return @"s-resize";
+            }
+            if ([NSCursor respondsToSelector:@selector(resizeLeftCursor)] &&
+                cursor == [NSCursor resizeLeftCursor]) {
+                return @"w-resize";
+            }
+            if ([NSCursor respondsToSelector:@selector(resizeRightCursor)] &&
+                cursor == [NSCursor resizeRightCursor]) {
+                return @"e-resize";
+            }
+        }
+        return nil;
     }
 
     // zoom-in/zoom-out: 28x26, ratio=1.077, hotspot rel=(0.428, 0.423)
@@ -1532,10 +1816,12 @@ static NSString* cursorTypeFromImageSignature(NSImage *image, NSPoint hotspot, N
         if (approxTight(relativeX, 0.161) && approxTight(relativeY, 0.1)) {
             return @"default";
         }
-        // context-menu/progress/wait/copy/no-drop/not-allowed: hotspot rel=(0.179, 0.125) - hotspot at (5, 5)
+        // Ortak 28x40 ok/beachball hotspot bandı: spinner ile karışmasın diye önce ok
         if (approxTight(relativeX, 0.179) && approxTight(relativeY, 0.125)) {
-            // Try pointer equality for standard cursors
             if (cursor) {
+                if (cursor == [NSCursor arrowCursor]) {
+                    return @"default";
+                }
                 if (cursor == [NSCursor contextualMenuCursor]) {
                     return @"context-menu";
                 }
@@ -1546,10 +1832,7 @@ static NSString* cursorTypeFromImageSignature(NSImage *image, NSPoint hotspot, N
                     return @"not-allowed";
                 }
             }
-            // NOTE: progress, wait, no-drop don't have standard NSCursor pointers
-            // Return "progress" as default for this hotspot pattern (better than "default")
-            // Let cursor name detection in caller distinguish between progress/wait
-            return @"progress";
+            return @"default";
         }
         return @"default";
     }
@@ -1576,13 +1859,16 @@ static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
     if (cursor == [NSCursor pointingHandCursor]) {
         return @"pointer";
     }
-    if (cursor == [NSCursor crosshairCursor]) {
+    if ([NSCursor respondsToSelector:@selector(crosshairCursor)] &&
+        cursor == [NSCursor crosshairCursor]) {
         return @"crosshair";
     }
-    if (cursor == [NSCursor openHandCursor]) {
+    if ([NSCursor respondsToSelector:@selector(openHandCursor)] &&
+        cursor == [NSCursor openHandCursor]) {
         return @"grab";
     }
-    if (cursor == [NSCursor closedHandCursor]) {
+    if ([NSCursor respondsToSelector:@selector(closedHandCursor)] &&
+        cursor == [NSCursor closedHandCursor]) {
         return @"grabbing";
     }
     if (cursor == [NSCursor operationNotAllowedCursor]) {
@@ -1598,14 +1884,42 @@ static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
         return @"context-menu";
     }
 
-    // Resize cursors
-    if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)]) {
-        if (cursor == [NSCursor resizeLeftRightCursor]) {
+    NSString *diagonalVisual = DiagonalResizeTypeByVisualMatch(cursor);
+    if (diagonalVisual) {
+        return diagonalVisual;
+    }
+
+    if ([NSCursor respondsToSelector:@selector(resizeLeftCursor)] &&
+        cursor == [NSCursor resizeLeftCursor]) {
+        return @"col-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeRightCursor)] &&
+        cursor == [NSCursor resizeRightCursor]) {
+        return @"col-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeUpCursor)] &&
+        cursor == [NSCursor resizeUpCursor]) {
+        return @"n-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeDownCursor)] &&
+        cursor == [NSCursor resizeDownCursor]) {
+        return @"s-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)] &&
+        cursor == [NSCursor resizeLeftRightCursor]) {
+        return @"col-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)] &&
+        cursor == [NSCursor resizeUpDownCursor]) {
+        return @"ns-resize";
+    }
+    if (@available(macOS 15.0, *)) {
+        if ([NSCursor respondsToSelector:@selector(columnResizeCursor)] &&
+            cursor == [NSCursor columnResizeCursor]) {
             return @"col-resize";
         }
-    }
-    if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)]) {
-        if (cursor == [NSCursor resizeUpDownCursor]) {
+        if ([NSCursor respondsToSelector:@selector(rowResizeCursor)] &&
+            cursor == [NSCursor rowResizeCursor]) {
             return @"row-resize";
         }
     }
@@ -1677,12 +1991,6 @@ static NSString* detectSystemCursorType(void) {
     }
 
     int cursorSeed = SafeCGSCurrentCursorSeed();
-    if (cursorSeed > 0) {
-        NSString *seedType = cursorTypeFromSeed(cursorSeed);
-        if (seedType) {
-            return seedType;
-        }
-    }
 
     void (^fetchCursorBlock)(void) = ^{
         NSCursor *currentCursor = nil;
@@ -1786,14 +2094,23 @@ static NSString* detectSystemCursorType(void) {
         dispatch_sync(dispatch_get_main_queue(), fetchCursorBlock);
     }
 
-    if (cursorType && ![cursorType isEqualToString:@"default"] && cursorSeed > 0) {
-        addCursorToSeedMap(cursorType, cursorSeed);
+    if (cursorType && ![cursorType isEqualToString:@"default"]) {
+        if (cursorSeed > 0) {
+            addCursorToSeedMap(cursorType, cursorSeed);
+        }
+        return cursorType;
     }
 
-    return cursorType;
+    if (cursorSeed > 0) {
+        NSString *seedType = cursorTypeFromSeed(cursorSeed);
+        if (seedType) {
+            return seedType;
+        }
+    }
+
+    return cursorType ?: @"default";
 }
 
-// Desktop'ta SVG karşılığı olmayan cursor tiplerini desteklenen tiplere normalize et
 static NSString* normalizeCursorTypeForDesktop(NSString *cursorType) {
     if (!cursorType || [cursorType length] == 0) {
         return @"default";
@@ -1891,11 +2208,23 @@ NSString* getCursorType() {
         int currentSeed = SafeCGSCurrentCursorSeed();
         g_lastCursorSeed = currentSeed; // Save for getCursorPosition()
 
-        // Use cursorTypeFromNSCursor for detection (pointer equality + image-based)
-        // DO NOT use accessibility detection as it's unreliable and causes false positives
+        // Önce NSCursor/CGS; köşe diagonal için sistem imleci güvenilir olmayabiliyor — AX ile pencere çerçevesi düzeltmesi
         NSString *systemCursorType = detectSystemCursorType();
         NSString *rawType = systemCursorType && [systemCursorType length] > 0 ? systemCursorType : @"default";
 
+        __block NSString *chromeResize = nil;
+        if ([NSThread isMainThread]) {
+            chromeResize = ResizeTypeFromWindowUnderCursor(cursorPos);
+        } else {
+            dispatch_sync(dispatch_get_main_queue(), ^{
+                chromeResize = ResizeTypeFromWindowUnderCursor(cursorPos);
+            });
+        }
+
+        if (chromeResize) {
+            rawType = chromeResize;
+        }
+
         // Desktop SVG'lerine uyumlu tipe normalize et
         NSString *finalType = normalizeCursorTypeForDesktop(rawType);
 
@@ -1947,29 +2276,6 @@ void writeToFile(NSDictionary *cursorData) {
     }
 }
 
-// Text input event: Klavye basıldığında focused text field'in caret pozisyonunu yakala
-static void emitTextInputEvent(NSTimeInterval timestamp, NSTimeInterval unixTimeMs, CGPoint mouseLocation) {
-    if (unixTimeMs - g_lastTextInputEmitTime < TEXT_INPUT_THROTTLE_MS) {
-        return;
-    }
-
-    NSDictionary *snap = MRTextInputSnapshotDictionary();
-    if (!snap) {
-        return;
-    }
-
-    NSMutableDictionary *textInputInfo = [NSMutableDictionary dictionaryWithDictionary:snap];
-    textInputInfo[@"x"] = @((int)mouseLocation.x);
-    textInputInfo[@"y"] = @((int)mouseLocation.y);
-    textInputInfo[@"timestamp"] = @(timestamp);
-    textInputInfo[@"unixTimeMs"] = @(unixTimeMs);
-    textInputInfo[@"cursorType"] = @"text";
-    textInputInfo[@"type"] = @"textInput";
-
-    writeToFile(textInputInfo);
-    g_lastTextInputEmitTime = unixTimeMs;
-}
-
 // Event callback for mouse events
 CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
     @autoreleasepool {
@@ -1996,23 +2302,6 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         // Event tipini belirle
         switch (type) {
             case kCGEventLeftMouseDown:
-                eventType = @"mousedown";
-                // Odak/caret çoğu uygulamada tıklamadan hemen sonra oluşur; kısa gecikmeyle AX caret yaz.
-                // (Sadece tuşta emit edilince ilk tıkta timeline'da textInput olmuyordu.)
-                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.028 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-                    if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) return;
-                    NSDate *now = [NSDate date];
-                    NSTimeInterval ts = [now timeIntervalSinceDate:g_trackingStartTime] * 1000.0;
-                    NSTimeInterval unixMs = [now timeIntervalSince1970] * 1000.0;
-                    CGPoint loc = CGPointZero;
-                    CGEventRef posEv = CGEventCreate(NULL);
-                    if (posEv) {
-                        loc = CGEventGetLocation(posEv);
-                        CFRelease(posEv);
-                    }
-                    emitTextInputEvent(ts, unixMs, loc);
-                });
-                break;
             case kCGEventRightMouseDown:
             case kCGEventOtherMouseDown:
                 eventType = @"mousedown";
@@ -2027,10 +2316,6 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             case kCGEventOtherMouseDragged:
                 eventType = @"drag";
                 break;
-            case kCGEventKeyDown:
-                // Klavye event'i — text caret tracking için
-                emitTextInputEvent(timestamp, unixTimeMs, location);
-                return event; // Mouse event olarak işleme, ayrı handle edildi
             case kCGEventMouseMoved:
             default:
                 eventType = @"move";
@@ -2040,7 +2325,7 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         if (!ShouldEmitCursorEvent(location, cursorType, eventType)) {
             return event;
         }
-
+        
         // Cursor data oluştur
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
@@ -2050,7 +2335,7 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             @"cursorType": cursorType,
             @"type": eventType
         };
-
+        
         // Direkt dosyaya yaz
         writeToFile(cursorInfo);
         RememberCursorEvent(location, cursorType, eventType);
@@ -2086,13 +2371,6 @@ void cursorTimerCallback() {
             cursorType = @"default";
         }
 
-        // Timer-only mod: CGEventTap yokken kCGEventKeyDown gelmez; caret satırları hiç yazılmazdı.
-        // I-beam görünürken AX ile periyodik textInput üret (emitTextInputEvent içinde throttle var).
-        if ([cursorType isEqualToString:@"text"] ||
-            [cursorType isEqualToString:@"vertical-text"]) {
-            emitTextInputEvent(timestamp, unixTimeMs, location);
-        }
-
         // Mouse button state polling — event tap olmadığında click/drag tespiti
         bool currentLeftMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonLeft);
         bool currentRightMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonRight);
@@ -2196,7 +2474,6 @@ void cleanupCursorTracking() {
     g_lastDetectedCursorType = nil;
     g_cursorTypeCounter = 0;
     g_isFirstWrite = true;
-    g_lastTextInputEmitTime = 0;
     ResetCursorEventHistory();
 }
 
@@ -2237,7 +2514,7 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
         g_trackingStartTime = [NSDate date];
         ResetCursorEventHistory();
         
-        // Create event tap for mouse + keyboard events
+        // Create event tap for mouse events
         CGEventMask eventMask = (CGEventMaskBit(kCGEventLeftMouseDown) |
                                 CGEventMaskBit(kCGEventLeftMouseUp) |
                                 CGEventMaskBit(kCGEventRightMouseDown) |
@@ -2247,8 +2524,7 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
                                 CGEventMaskBit(kCGEventMouseMoved) |
                                 CGEventMaskBit(kCGEventLeftMouseDragged) |
                                 CGEventMaskBit(kCGEventRightMouseDragged) |
-                                CGEventMaskBit(kCGEventOtherMouseDragged) |
-                                CGEventMaskBit(kCGEventKeyDown));
+                                CGEventMaskBit(kCGEventOtherMouseDragged));
         
         bool eventTapActive = false;
         g_eventTap = CGEventTapCreate(kCGSessionEventTap,
@@ -2578,33 +2854,6 @@ Napi::Value GetCursorDebugInfo(const Napi::CallbackInfo& info) {
     }
 }
 
-static Napi::Value DictToNapiTextInputSnapshot(Napi::Env env, NSDictionary *snap) {
-    Napi::Object o = Napi::Object::New(env);
-    NSNumber *cx = snap[@"caretX"];
-    NSNumber *cy = snap[@"caretY"];
-    o.Set("caretX", Napi::Number::New(env, cx ? [cx doubleValue] : 0));
-    o.Set("caretY", Napi::Number::New(env, cy ? [cy doubleValue] : 0));
-    NSDictionary *frame = snap[@"inputFrame"];
-    Napi::Object fo = Napi::Object::New(env);
-    if ([frame isKindOfClass:[NSDictionary class]]) {
-        fo.Set("x", Napi::Number::New(env, [frame[@"x"] doubleValue]));
-        fo.Set("y", Napi::Number::New(env, [frame[@"y"] doubleValue]));
-        fo.Set("width", Napi::Number::New(env, [frame[@"width"] doubleValue]));
-        fo.Set("height", Napi::Number::New(env, [frame[@"height"] doubleValue]));
-    }
-    o.Set("inputFrame", fo);
-    return o;
-}
-
-static Napi::Value GetTextInputSnapshot(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    NSDictionary *snap = MRTextInputSnapshotDictionary();
-    if (!snap) {
-        return env.Null();
-    }
-    return DictToNapiTextInputSnapshot(env, snap);
-}
-
 // Export functions
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
     exports.Set("startCursorTracking", Napi::Function::New(env, StartCursorTracking));
@@ -2612,7 +2861,6 @@ Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
     exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPosition));
     exports.Set("getCursorTrackingStatus", Napi::Function::New(env, GetCursorTrackingStatus));
     exports.Set("getCursorDebugInfo", Napi::Function::New(env, GetCursorDebugInfo));
-    exports.Set("getTextInputSnapshot", Napi::Function::New(env, GetTextInputSnapshot));
 
     return exports;
 }