node-mac-recorder 2.24.0 → 2.24.2

package/index.js

@@ -150,6 +150,23 @@ class MacRecorder extends EventEmitter {
 	/**
 	 * macOS ekranlarını listeler
 	 */
+	/**
+	 * ScreenCaptureKit'i onceden isitir (SCShareableContent cache).
+	 * Kayit baslatmadan once cagrilirsa "start recorder" gecikmesi belirgin azalir.
+	 * Asenkron ve guvenli: desteklenmeyen surumlerde sessizce false doner.
+	 */
+	prewarmScreenCapture() {
+		try {
+			if (typeof nativeBinding.prewarmScreenCapture !== "function") {
+				return false;
+			}
+			return nativeBinding.prewarmScreenCapture();
+		} catch (error) {
+			console.warn("Prewarm basarisiz:", error.message);
+			return false;
+		}
+	}
+
 	async getDisplays() {
 		const displays = nativeBinding.getDisplays();
 		return displays.map((display, index) => ({
@@ -866,6 +883,31 @@ class MacRecorder extends EventEmitter {
 					this.recordingStartTime = syncTimestamp;
 					console.log(`🎯 CURSOR SYNC: Cursor tracking will use timestamp: ${syncTimestamp}`);
 
+					// CURSOR/VIDEO TIME ALIGNMENT:
+					// Cursor timeline'in t=0'i bu andir (syncTimestamp), ama videonun
+					// ILK KARESI daha once yakalanmis olabilir (ScreenCaptureKit
+					// baslatma gecikmesi + yukaridaki hazir-olma beklemesi). Editor
+					// "cursor'un ilk ornegi = video t=0" varsayarsa aradaki fark sabit
+					// bir zaman kaymasi olarak kalir. Native gercek video baslangicini
+					// biliyor; okuyup sakla ki stop'ta cursor JSON'una yazabilelim.
+					this.videoStartTimestamp = 0;
+					try {
+						const nativeVideoStart =
+							typeof nativeBinding.getVideoStartTimestamp === 'function'
+								? Number(nativeBinding.getVideoStartTimestamp())
+								: 0;
+						if (Number.isFinite(nativeVideoStart) && nativeVideoStart > 0) {
+							this.videoStartTimestamp = nativeVideoStart;
+							console.log(
+								`🎯 SYNC: Video first-frame timestamp: ${nativeVideoStart} (cursor starts ${(syncTimestamp - nativeVideoStart).toFixed(0)}ms later)`
+							);
+						} else {
+							console.warn('⚠️ SYNC: Video start timestamp unavailable — cursor sync metadata will be skipped');
+						}
+					} catch (videoStartError) {
+						console.warn('⚠️ SYNC: Video start timestamp read failed:', videoStartError.message);
+					}
+
 					const standardCursorOptions = {
 						videoRelative: true,
 						displayInfo: this.recordingDisplayInfo,
@@ -1709,12 +1751,20 @@ class MacRecorder extends EventEmitter {
 				this.cursorCaptureInterval = null;
 
 				// Dosyayı kapat
+				let closedCursorFile = null;
 				if (this.cursorCaptureFile) {
 					const fs = require("fs");
 					fs.appendFileSync(this.cursorCaptureFile, "]");
+					closedCursorFile = this.cursorCaptureFile;
 					this.cursorCaptureFile = null;
 				}
 
+				// Cursor/video zaman hizalama bilgisini dosyaya yaz (editör bunu
+				// okuyup sabit kaymayı telafi ediyor).
+				if (closedCursorFile) {
+					this._writeCursorSyncMetadata(closedCursorFile);
+				}
+
 				// Değişkenleri temizle
 				this.lastCapturedData = null;
 				this.cursorCaptureStartTime = null;
@@ -1729,6 +1779,58 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Cursor JSON'una video/cursor zaman hizalama bilgisini yazar.
+	 *
+	 * NEDEN: Cursor timeline'inin t=0'i `syncTimestamp` (kayit hazir olduktan
+	 * sonraki an), videonun t=0'i ise ILK KARENIN yakalandigi an. ScreenCaptureKit
+	 * baslatma gecikmesi yuzunden bu ikisi ayni degil; fark bilinmezse oynatimda
+	 * sabit bir zaman kaymasi olusur (cursor video ile "sync tutmuyor").
+	 * Editor tarafi `_syncMetadata.videoStartTime` / `cursorStartTime` okuyup
+	 * tam telafi ediyor — burada sadece gercek degerleri yaziyoruz.
+	 *
+	 * Dosyanin ilk noktasina yazilir; okuyucu ilk metadata'yi bulup kullanir.
+	 */
+	_writeCursorSyncMetadata(cursorFilePath) {
+		const videoStartTime = Number(this.videoStartTimestamp);
+		const cursorStartTime = Number(this.syncTimestamp);
+		if (
+			!Number.isFinite(videoStartTime) ||
+			videoStartTime <= 0 ||
+			!Number.isFinite(cursorStartTime) ||
+			cursorStartTime <= 0
+		) {
+			// Native video baslangici okunamadiysa metadata yazma — editor eski
+			// (telafisiz) davranisa duser, yanlis bir offset uygulamaktan iyidir.
+			return;
+		}
+
+		try {
+			const fs = require("fs");
+			const raw = fs.readFileSync(cursorFilePath, "utf8");
+			const positions = JSON.parse(raw);
+			if (!Array.isArray(positions) || positions.length === 0) return;
+
+			positions[0]._syncMetadata = {
+				videoStartTime,
+				cursorStartTime,
+				startDelayMs: cursorStartTime - videoStartTime,
+				recordingType: this.options?.windowId
+					? "window"
+					: this.options?.captureArea
+						? "area"
+						: "display",
+			};
+
+			fs.writeFileSync(cursorFilePath, JSON.stringify(positions));
+			console.log(
+				`🎯 SYNC: Cursor sync metadata written (video→cursor delay ${(cursorStartTime - videoStartTime).toFixed(0)}ms)`
+			);
+		} catch (error) {
+			console.warn("⚠️ SYNC: Cursor sync metadata write failed:", error.message);
+		}
+	}
+
 	/**
 	 * Klavye kısayolu (shortcut) yakalamayı başlatır.
 	 * Native CGEventTap keyDown olaylarını dinler; yalnızca ⌘/⌃/⌥ modifier'lı

package/package.json

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

package/src/cursor_tracker.mm

@@ -153,23 +153,7 @@ static uint64_t FNV1AHash(const unsigned char *data, size_t length) {
     return hash;
 }
 
-static NSString* CursorImageFingerprintFromImage(NSImage *image, NSPoint hotspot) {
-    if (!image) {
-        return nil;
-    }
-    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;
-                }
-            }
-        }
-    }
-
+static NSString* CursorImageFingerprintFromCGImage(CGImageRef cgImage, NSPoint hotspot) {
     if (!cgImage) {
         return nil;
     }
@@ -223,6 +207,67 @@ static NSString* CursorImageFingerprintFromImage(NSImage *image, NSPoint hotspot
             hash];
 }
 
+// NSImage'in VARSAYILAN temsilinden fingerprint. Hangi temsilin seçildigi ekranin
+// backing scale'ine bagli (Retina 2x vs harici 1x), bu yuzden calisma aninda
+// uretilen deger ekran konfigurasyonuna gore degisebilir.
+static NSString* CursorImageFingerprintFromImage(NSImage *image, NSPoint hotspot) {
+    if (!image) {
+        return nil;
+    }
+    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;
+                }
+            }
+        }
+    }
+
+    return CursorImageFingerprintFromCGImage(cgImage, hotspot);
+}
+
+// Bir cursor imajinin TUM temsilleri icin fingerprint uretir.
+// KRITIK: MacBook kapagi kapaliyken tek harici monitorde calisirken (clamshell)
+// veya ekranlar arasi gecerken NSImage farkli bir temsil donduruyor; tek fingerprint
+// kaydedilirse eslesme kayboluyor ve cursor tipi yanlis tespit ediliyordu.
+// Tum temsilleri kaydedince calisma aninda hangisi secilirse secilsin eslesme tutar.
+static NSArray<NSString *>* CursorImageFingerprintsAllReps(NSImage *image, NSPoint hotspot) {
+    if (!image) {
+        return @[];
+    }
+
+    NSMutableArray<NSString *> *fingerprints = [NSMutableArray array];
+
+    NSString *defaultFingerprint = CursorImageFingerprintFromImage(image, hotspot);
+    if (defaultFingerprint) {
+        [fingerprints addObject:defaultFingerprint];
+    }
+
+    for (NSImageRep *rep in [image representations]) {
+        CGImageRef repImage = NULL;
+        if ([rep isKindOfClass:[NSBitmapImageRep class]]) {
+            repImage = [(NSBitmapImageRep *)rep CGImage];
+        } else {
+            NSRect repRect = NSMakeRect(0, 0, [rep pixelsWide], [rep pixelsHigh]);
+            if (repRect.size.width <= 0 || repRect.size.height <= 0) {
+                repRect = NSMakeRect(0, 0, [rep size].width, [rep size].height);
+            }
+            repImage = [rep CGImageForProposedRect:&repRect context:nil hints:nil];
+        }
+
+        NSString *repFingerprint = CursorImageFingerprintFromCGImage(repImage, hotspot);
+        if (repFingerprint && ![fingerprints containsObject:repFingerprint]) {
+            [fingerprints addObject:repFingerprint];
+        }
+    }
+
+    return fingerprints;
+}
+
 static NSString* CursorImageFingerprintUnsafe(NSCursor *cursor) {
     if (!cursor) {
         return nil;
@@ -313,11 +358,17 @@ static void AddStandardCursorFingerprint(NSCursor *cursor, NSString *cursorType)
     if (!cursor || !cursorType) {
         return;
     }
-    NSString *fingerprint = CursorImageFingerprintUnsafe(cursor);
-    if (!fingerprint) {
-        return;
+    // Tek bir temsil degil, tum temsiller kaydedilir -> ekran olcegi degisse bile
+    // (clamshell / harici monitor) eslesme korunur.
+    NSArray<NSString *> *fingerprints =
+        CursorImageFingerprintsAllReps([cursor image], [cursor hotSpot]);
+    for (NSString *fingerprint in fingerprints) {
+        // Ilk kayit kazanir: ayni fingerprint birden fazla cursor'a denk gelirse
+        // once eklenen (daha spesifik) tip korunur.
+        if (![g_cursorFingerprintMap objectForKey:fingerprint]) {
+            [g_cursorFingerprintMap setObject:cursorType forKey:fingerprint];
+        }
     }
-    [g_cursorFingerprintMap setObject:cursorType forKey:fingerprint];
 }
 
 static void AddCursorIfAvailable(SEL selector, NSString *cursorType) {

package/src/mac_recorder.mm

@@ -1344,6 +1344,19 @@ Napi::Value GetVideoStartTimestamp(const Napi::CallbackInfo& info) {
 }
 
 // NAPI Function: Get Recording Status
+// Kayit baslatma gecikmesini azaltmak icin SCShareableContent'i onceden isitir.
+// Asenkron; hemen doner ve hicbir seyi bloklamaz.
+Napi::Value PrewarmScreenCapture(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (@available(macOS 12.3, *)) {
+        [ScreenCaptureKitRecorder prewarmShareableContent];
+        return Napi::Boolean::New(env, true);
+    }
+
+    return Napi::Boolean::New(env, false);
+}
+
 Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
 
@@ -1711,6 +1724,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "getDisplays"), Napi::Function::New(env, GetDisplays));
     exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, GetWindows));
     exports.Set(Napi::String::New(env, "getRecordingStatus"), Napi::Function::New(env, GetRecordingStatus));
+    exports.Set(Napi::String::New(env, "prewarmScreenCapture"), Napi::Function::New(env, PrewarmScreenCapture));
     exports.Set(Napi::String::New(env, "getVideoStartTimestamp"), Napi::Function::New(env, GetVideoStartTimestamp));
     exports.Set(Napi::String::New(env, "checkPermissions"), Napi::Function::New(env, CheckPermissions));
     

package/src/screen_capture_kit.h

@@ -7,6 +7,11 @@ API_AVAILABLE(macos(12.3))
 
 + (BOOL)isScreenCaptureKitAvailable;
 
+// SCShareableContent'i onceden cekerek macOS ic cache'ini isitir.
+// Kayit anindaki ilk cagri yavas oldugu icin (ozellikle ekran konfigurasyonu
+// degistikten sonra) baslatma gecikmesini azaltir. Asenkron, hicbir seyi bloklamaz.
++ (void)prewarmShareableContent;
+
 // MULTI-SESSION API: New session-based recording
 + (NSString *)startRecordingWithConfiguration:(NSDictionary *)config
                                      delegate:(id)delegate

package/src/screen_capture_kit.mm

@@ -1039,6 +1039,25 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     return NO;
 }
 
++ (void)prewarmShareableContent {
+    if (@available(macOS 15.0, *)) {
+        // Kayit sirasindaki ilk SCShareableContent cagrisi yavas olabiliyor
+        // (TCC kontrolu + pencere/ekran envanteri). Kayit baslamadan once bir kez
+        // cagirip macOS'un ic cache'ini isitiyoruz. Sonuc kullanilmiyor.
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
+            [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
+                if (contentError) {
+                    MRLog(@"⚠️ Prewarm shareable content failed: %@", contentError.localizedDescription);
+                    return;
+                }
+                MRLog(@"🔥 Prewarm: shareable content hazir (%lu ekran, %lu pencere)",
+                      (unsigned long)content.displays.count,
+                      (unsigned long)content.windows.count);
+            }];
+        });
+    }
+}
+
 + (BOOL)startRecordingWithConfiguration:(NSDictionary *)config delegate:(id)delegate error:(NSError **)error {
     if (!config) {
         return NO;

package/src/window_selector.mm

@@ -157,6 +157,24 @@ static void ApplyStartRecordButtonIcon(NSButton *button) {
     }
 }
 
+// CGWindow (sol-üst orijin) <-> Cocoa (sol-alt orijin) dönüşümünde referans yükseklik
+// DAİMA primary ekranın (screens[0]) yüksekliğidir. [NSScreen mainScreen] farenin/aktif
+// pencerenin bulunduğu ekranı döner; çok ekranlı kurulumda kullanılırsa highlight kayar.
+static CGFloat primaryScreenHeight() {
+    NSArray *screens = [NSScreen screens];
+    if ([screens count] == 0) return [[NSScreen mainScreen] frame].size.height;
+    return [[screens objectAtIndex:0] frame].size.height;
+}
+
+// Bir NSScreen frame'ini (Cocoa global) CGWindow koordinat uzayına çevirir
+static NSRect screenFrameInCGSpace(NSScreen *screen) {
+    NSRect f = [screen frame];
+    return NSMakeRect(f.origin.x,
+                      primaryScreenHeight() - NSMaxY(f),
+                      f.size.width,
+                      f.size.height);
+}
+
 // Forward declarations
 void cleanupWindowSelector();
 void updateOverlay();
@@ -234,7 +252,8 @@ void updateScreenOverlays();
     }
     
     // Draw highlight rectangle for the selected window
-    NSBezierPath *highlightPath = [NSBezierPath bezierPathWithRoundedRect:self.highlightFrame
+    // 1px stroke'un yarısı dışarı taşmasın diye 0.5px içeri al -> pencereye tam otursun
+    NSBezierPath *highlightPath = [NSBezierPath bezierPathWithRoundedRect:NSInsetRect(self.highlightFrame, 0.5, 0.5)
                                                                   xRadius:8.0
                                                                   yRadius:8.0];
     
@@ -852,9 +871,10 @@ void updateOverlay() {
         // Get current cursor position
         NSPoint mouseLocation = [NSEvent mouseLocation];
         // Convert from NSEvent coordinates (bottom-left) to CGWindow coordinates (top-left)
-        NSScreen *mainScreen = [NSScreen mainScreen];
-        CGFloat screenHeight = [mainScreen frame].size.height;
-        CGPoint globalPoint = CGPointMake(mouseLocation.x, screenHeight - mouseLocation.y);
+        // NOT: referans DAİMA primary ekran yüksekliği; mainScreen kullanılırsa imleç
+        // farklı bir ekrana geçtiğinde koordinat kayar ve yanlış pencere seçilir.
+        CGPoint globalPoint = CGPointMake(mouseLocation.x,
+                                          primaryScreenHeight() - mouseLocation.y);
         
         // Find window under cursor (no need to refresh g_allWindows frequently since windows can't move)
         NSDictionary *windowUnderCursor = getWindowUnderCursor(globalPoint);
@@ -961,27 +981,21 @@ void updateOverlay() {
             CGFloat windowCenterY = y + height / 2;
             
             for (NSScreen *screen in screens) {
-                NSRect screenFrame = [screen frame];
-                // Convert screen frame to CGWindow coordinates
-                CGFloat screenTop = screenFrame.origin.y + screenFrame.size.height;
-                CGFloat screenBottom = screenFrame.origin.y;
-                CGFloat screenLeft = screenFrame.origin.x;
-                CGFloat screenRight = screenFrame.origin.x + screenFrame.size.width;
-                
-                if (windowCenterX >= screenLeft && windowCenterX <= screenRight &&
-                    windowCenterY >= screenBottom && windowCenterY <= screenTop) {
+                // Pencere koordinatları CGWindow uzayında; ekran frame'ini de aynı uzaya çevir
+                NSRect cgScreen = screenFrameInCGSpace(screen);
+
+                if (windowCenterX >= NSMinX(cgScreen) && windowCenterX <= NSMaxX(cgScreen) &&
+                    windowCenterY >= NSMinY(cgScreen) && windowCenterY <= NSMaxY(cgScreen)) {
                     windowScreen = screen;
                     break;
                 }
             }
-            
+
             // Use main screen if no specific screen found
             if (!windowScreen) windowScreen = [NSScreen mainScreen];
-            
-            // Convert coordinates from CGWindow (top-left) to NSWindow (bottom-left) for the specific screen
-            NSRect screenFrame = [windowScreen frame];
-            CGFloat screenHeight = screenFrame.size.height;
-            CGFloat adjustedY = screenHeight - y - height;
+
+            // Convert coordinates from CGWindow (top-left) to Cocoa global (bottom-left)
+            CGFloat adjustedY = primaryScreenHeight() - y - height;
             
             // Window coordinates are in global space, overlay frame should be screen-relative
             // Keep X coordinate as-is (already in global space which is what we want)
@@ -1014,19 +1028,19 @@ void updateOverlay() {
             NSInteger targetScreenIndex = -1;
             NSScreen *targetScreen = nil;
             
-            // Find screen containing this window
+            // Find screen containing this window (karşılaştırma CGWindow uzayında yapılmalı)
             for (NSInteger i = 0; i < [allScreens count]; i++) {
                 NSScreen *screen = [allScreens objectAtIndex:i];
-                NSRect screenFrame = [screen frame];
-                
+                NSRect cgScreen = screenFrameInCGSpace(screen);
+
                 // Check if window center is within this screen bounds
                 CGFloat windowCenterX = x + width/2;
                 CGFloat windowCenterY = y + height/2;
-                
-                if (windowCenterX >= screenFrame.origin.x && 
-                    windowCenterX <= screenFrame.origin.x + screenFrame.size.width &&
-                    windowCenterY >= screenFrame.origin.y && 
-                    windowCenterY <= screenFrame.origin.y + screenFrame.size.height) {
+
+                if (windowCenterX >= NSMinX(cgScreen) &&
+                    windowCenterX <= NSMaxX(cgScreen) &&
+                    windowCenterY >= NSMinY(cgScreen) &&
+                    windowCenterY <= NSMaxY(cgScreen)) {
                     targetScreenIndex = i;
                     targetScreen = screen;
                     break;
@@ -1043,9 +1057,10 @@ void updateOverlay() {
             WindowSelectorOverlayView *targetOverlayView = [g_perScreenOverlayViews objectAtIndex:targetScreenIndex];
             NSRect targetScreenFrame = [targetScreen frame];
             
-            // Calculate LOCAL coordinates within target screen (much simpler!)
+            // Calculate LOCAL coordinates within target screen
+            // CG (sol-üst, primary orijinli) -> Cocoa global (sol-alt) -> ekran-yerel
             CGFloat localX = x - targetScreenFrame.origin.x;
-            CGFloat localY = (targetScreenFrame.size.height - (y - targetScreenFrame.origin.y)) - height;
+            CGFloat localY = (primaryScreenHeight() - y - height) - targetScreenFrame.origin.y;
             
             NSLog(@"🎯 Window on Screen %ld: Global(%.0f,%.0f) → Local(%.0f,%.0f)", 
                   targetScreenIndex, (CGFloat)x, (CGFloat)y, localX, localY);
@@ -2177,12 +2192,16 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
             NSRect screenFrame = [screen frame];
             
             // Create per-screen overlay window
+            // NOT: screen: parametresi non-nil verilirse contentRect o ekranın sol-alt köşesine
+            // GÖRE yorumlanır; global screenFrame ile birlikte çift offset oluşur. nil verip
+            // frame'i global koordinatta açıkça set ediyoruz.
             NSWindow *screenOverlay = [[NoFocusWindow alloc] initWithContentRect:screenFrame
                                                                         styleMask:NSWindowStyleMaskBorderless
                                                                           backing:NSBackingStoreBuffered
                                                                             defer:NO
-                                                                           screen:screen];
-            
+                                                                           screen:nil];
+            [screenOverlay setFrame:screenFrame display:NO];
+
             // Create per-screen overlay view
             WindowSelectorOverlayView *overlayView = [[WindowSelectorOverlayView alloc] initWithFrame:NSMakeRect(0, 0, screenFrame.size.width, screenFrame.size.height)];
             [screenOverlay setContentView:overlayView];