node-mac-recorder 2.22.32 → 2.22.33

package/MultiWindowRecorder.js

@@ -223,6 +223,7 @@ class MultiWindowRecorder extends EventEmitter {
                         } : null,
                         recordingType: 'multi-window', // Multi-window recording type
                         startTimestamp: startTimestamp, // Use same timestamp as video
+                        interval: 33,
                         // Pass window information for location detection
                         multiWindowBounds: windowBounds
                     };

package/index.js

@@ -869,7 +869,8 @@ class MacRecorder extends EventEmitter {
 									  this.options.captureArea ? 'area' : 'display',
 						captureArea: this.options.captureArea,
 						windowId: this.options.windowId,
-						startTimestamp: syncTimestamp // Align cursor timeline to actual start
+						startTimestamp: syncTimestamp,
+						interval: 33,
 					};
 
 					try {
@@ -1348,6 +1349,13 @@ class MacRecorder extends EventEmitter {
 			return true; // İlk event
 		}
 
+		if (
+			currentData.type === "drag" ||
+			currentData.type === "rightdrag"
+		) {
+			return true;
+		}
+
 		const last = this.lastCapturedData;
 
 		// Event type değişmişse
@@ -1382,10 +1390,11 @@ class MacRecorder extends EventEmitter {
 	 * @param {Object} options.captureArea - Capture area for area recording coordinate transformation
 	 * @param {number} options.windowId - Window ID for window recording coordinate transformation
 	 * @param {number} options.startTimestamp - Pre-defined start timestamp for synchronization (optional)
+	 * @param {number} options.interval - Örnekleme aralığı (ms), filepath ile çağrıda kullanılır; varsayılan 33ms (~30 Hz)
 	 */
 	async startCursorCapture(intervalOrFilepath = 100, options = {}) {
 		let filepath;
-		let interval = 20; // Default 50 FPS
+		let interval = 33;
 
 		// Parameter parsing: number = interval, string = filepath
 		if (typeof intervalOrFilepath === "number") {
@@ -1399,6 +1408,10 @@ class MacRecorder extends EventEmitter {
 			);
 		}
 
+		if (typeof options.interval === "number") {
+			interval = Math.max(10, options.interval);
+		}
+
 		if (this.cursorCaptureInterval) {
 			throw new Error("Cursor capture is already running");
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.22.32",
+	"version": "2.22.33",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [
@@ -43,7 +43,9 @@
 		"build:electron-safe": "node build-electron-safe.js",
 		"test:electron-safe": "node test-electron-safe.js",
 		"clean:electron-safe": "node-gyp clean && rm -rf build",
-		"canvas": "node make-canvas.js"
+		"canvas": "node make-canvas.js",
+		"cursor:live": "node scripts/cursor-type-live.js",
+		"test:cursor-types": "node scripts/cursor-types-15s-test.js"
 	},
 	"dependencies": {
 		"node-addon-api": "^7.0.0"

package/scripts/cursor-type-live.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+const MacRecorder = require('../index.js');
+
+const INTERVAL_MS = 33;
+
+const recorder = new MacRecorder();
+
+process.stderr.write(
+	`Canlı cursor tipi (${INTERVAL_MS}ms). Çıkmak: Ctrl+C\n`
+);
+
+function tick() {
+	try {
+		const p = recorder.getCursorPosition();
+		const type = p.cursorType != null ? String(p.cursorType) : '?';
+		const seed =
+			typeof p.seed === 'number' && p.seed > 0 ? ` seed:${p.seed}` : '';
+		process.stdout.write(`\r\x1b[KcursorType: ${type}${seed}`);
+	} catch (e) {
+		process.stdout.write(`\r\x1b[K${e.message || e}`);
+	}
+}
+
+const id = setInterval(tick, INTERVAL_MS);
+tick();
+
+process.on('SIGINT', () => {
+	clearInterval(id);
+	process.stdout.write('\n');
+	process.exit(0);
+});

package/scripts/cursor-types-15s-test.js

@@ -0,0 +1,122 @@
+const fs = require('fs');
+const path = require('path');
+
+const MacRecorder = require('../index.js');
+
+const OUT_DIR = path.join(__dirname, '..', 'test-output');
+const DURATION_SEC = 15;
+
+async function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+function summarizeCursorTypes(cursorJsonPath) {
+	if (!cursorJsonPath || !fs.existsSync(cursorJsonPath)) {
+		return { counts: {}, ordered: [] };
+	}
+	const raw = fs.readFileSync(cursorJsonPath, 'utf8');
+	let events;
+	try {
+		events = JSON.parse(raw);
+	} catch {
+		return { counts: {}, ordered: [] };
+	}
+	if (!Array.isArray(events)) {
+		return { counts: {}, ordered: [] };
+	}
+	const counts = {};
+	const order = [];
+	for (const ev of events) {
+		const t = ev && ev.cursorType ? String(ev.cursorType) : '?';
+		if (counts[t] === undefined) {
+			counts[t] = 0;
+			order.push(t);
+		}
+		counts[t]++;
+	}
+	return { counts, ordered: order };
+}
+
+async function main() {
+	fs.mkdirSync(OUT_DIR, { recursive: true });
+
+	const stamp = Date.now();
+	const screenPath = path.join(OUT_DIR, `cursor-types-test-${stamp}.mov`);
+
+	const recorder = new MacRecorder();
+
+	const displays = await recorder.getDisplays();
+	const cameras = await recorder.getCameraDevices();
+	const audioDevices = await recorder.getAudioDevices();
+
+	if (!displays.length) {
+		process.stderr.write('No displays.\n');
+		process.exit(1);
+	}
+
+	const display = displays[0];
+
+	let cursorPathFromStart = null;
+	recorder.once('recordingStarted', (info) => {
+		cursorPathFromStart = info.cursorOutputPath || null;
+	});
+
+	const options = {
+		displayId: display.id,
+		captureCamera: cameras.length > 0,
+		cameraDeviceId: cameras.length > 0 ? cameras[0].id : undefined,
+		includeMicrophone: audioDevices.length > 0,
+		audioDeviceId: audioDevices.length > 0 ? audioDevices[0].id : undefined,
+		includeSystemAudio: true,
+		captureCursor: true,
+		frameRate: 60,
+	};
+
+	process.stdout.write(
+		`Kayıt ${DURATION_SEC}s: ekran + sistem sesi + mik ${
+			options.includeMicrophone ? 'açık' : 'kapalı'
+		} + kamera ${options.captureCamera ? 'açık' : 'kapalı'} + cursor JSON.\n` +
+			`Kenarlarda resize, köşelerde çapraz, grab/grabbing ve crosshair deneyin.\n\n`
+	);
+
+	await recorder.startRecording(screenPath, options);
+
+	const cursorPath = cursorPathFromStart;
+
+	for (let i = 1; i <= DURATION_SEC; i++) {
+		await sleep(1000);
+		process.stdout.write(`${i}s `);
+	}
+	process.stdout.write('\n');
+
+	await recorder.stopRecording();
+
+	process.stdout.write('\nDosyalar:\n');
+	process.stdout.write(`  Ekran: ${screenPath}\n`);
+	if (options.captureCamera && cameras.length) {
+		process.stdout.write(
+			`  Kamera: kayıt başladıktan sonra native temp_camera_* ile aynı oturum\n`
+		);
+	}
+	if (options.includeMicrophone || options.includeSystemAudio) {
+		process.stdout.write(
+			`  Ses: kayıt başladıktan sonra native temp_audio_* ile aynı oturum\n`
+		);
+	}
+	process.stdout.write(`  Cursor JSON: ${cursorPath || 'bilinmiyor'}\n`);
+
+	if (cursorPath && fs.existsSync(cursorPath)) {
+		const { counts, ordered } = summarizeCursorTypes(cursorPath);
+		process.stdout.write('\nCursor JSON — cursorType özeti (ilk görülme sırası):\n');
+		for (const t of ordered) {
+			process.stdout.write(`  ${t}: ${counts[t]}\n`);
+		}
+	}
+
+	recorder.removeAllListeners();
+}
+
+main().catch((e) => {
+	process.stderr.write(String(e && e.message ? e.message : e) + '\n');
+	process.exit(1);
+});

package/src/cursor_tracker.mm

@@ -8,6 +8,7 @@
 #import <dispatch/dispatch.h>
 #import "logging.h"
 #include <vector>
+#include <cstring>
 #include <math.h>
 
 #ifndef kAXHitTestParameterizedAttribute
@@ -309,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;
@@ -359,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");
@@ -502,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;
 }
@@ -670,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;
@@ -680,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";
     }
@@ -701,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;
@@ -937,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"] ||
@@ -1383,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
@@ -1422,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)
@@ -1505,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)
@@ -1527,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";
                 }
@@ -1541,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";
     }
@@ -1571,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]) {
@@ -1593,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";
         }
     }
@@ -1672,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;
@@ -1781,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";
@@ -1886,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);
 

package/src/electron_safe/cursor_tracker_electron.mm

@@ -3,6 +3,22 @@
 #import <AppKit/AppKit.h>
 #import "../logging.h"
 
+static NSCursor *CursorFactoryNamed(NSString *name) {
+    if (!name || [name length] == 0) return nil;
+    SEL sel = NSSelectorFromString(name);
+    if (!sel || ![NSCursor respondsToSelector:sel]) return nil;
+    IMP imp = [NSCursor methodForSelector:sel];
+    if (!imp) return nil;
+    typedef NSCursor *(*CursorFactoryFunc)(id, SEL);
+    CursorFactoryFunc fn = (CursorFactoryFunc)imp;
+    return fn([NSCursor class], sel);
+}
+
+static BOOL CursorEqualsFactoryNamed(NSCursor *cursor, NSString *factoryName) {
+    NSCursor *ref = CursorFactoryNamed(factoryName);
+    return ref != nil && cursor == ref;
+}
+
 // Thread-safe cursor tracking for Electron
 static dispatch_queue_t g_cursorQueue = nil;
 
@@ -23,18 +39,34 @@ static NSString* MapCursorToType(NSCursor *cursor) {
     if (cursor == [NSCursor pointingHandCursor]) return @"pointer";
     if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)]) {
         if (cursor == [NSCursor resizeLeftRightCursor] ||
-            [NSCursor instancesRespondToSelector:@selector(resizeLeftCursor)] && (cursor == [NSCursor resizeLeftCursor]) ||
-            [NSCursor instancesRespondToSelector:@selector(resizeRightCursor)] && (cursor == [NSCursor resizeRightCursor])) {
+            ([NSCursor respondsToSelector:@selector(resizeLeftCursor)] && cursor == [NSCursor resizeLeftCursor]) ||
+            ([NSCursor respondsToSelector:@selector(resizeRightCursor)] && cursor == [NSCursor resizeRightCursor])) {
             return @"col-resize";
         }
     }
     if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)]) {
         if (cursor == [NSCursor resizeUpDownCursor] ||
-            [NSCursor instancesRespondToSelector:@selector(resizeUpCursor)] && (cursor == [NSCursor resizeUpCursor]) ||
-            [NSCursor instancesRespondToSelector:@selector(resizeDownCursor)] && (cursor == [NSCursor resizeDownCursor])) {
+            ([NSCursor respondsToSelector:@selector(resizeUpCursor)] && cursor == [NSCursor resizeUpCursor]) ||
+            ([NSCursor respondsToSelector:@selector(resizeDownCursor)] && cursor == [NSCursor resizeDownCursor])) {
             return @"ns-resize";
         }
     }
+    if (CursorEqualsFactoryNamed(cursor, @"resizeNorthWestSouthEastCursor")) {
+        return @"nwse-resize";
+    }
+    if (CursorEqualsFactoryNamed(cursor, @"resizeNorthEastSouthWestCursor")) {
+        return @"nesw-resize";
+    }
+    if (@available(macOS 15.0, *)) {
+        if ([NSCursor respondsToSelector:@selector(columnResizeCursor)] &&
+            cursor == [NSCursor columnResizeCursor]) {
+            return @"col-resize";
+        }
+        if ([NSCursor respondsToSelector:@selector(rowResizeCursor)] &&
+            cursor == [NSCursor rowResizeCursor]) {
+            return @"row-resize";
+        }
+    }
     if ([NSCursor respondsToSelector:@selector(openHandCursor)] && cursor == [NSCursor openHandCursor]) return @"grab";
     if ([NSCursor respondsToSelector:@selector(closedHandCursor)] && cursor == [NSCursor closedHandCursor]) return @"grabbing";
     if ([NSCursor respondsToSelector:@selector(crosshairCursor)] && cursor == [NSCursor crosshairCursor]) return @"crosshair";