node-mac-recorder 2.21.24 → 2.21.25

package/index.js

@@ -551,8 +551,7 @@ class MacRecorder extends EventEmitter {
 					console.warn('❌ Native recording failed to start:', error.message);
 				}
 
-				// CRITICAL SYNC FIX: Wait for first video frame before starting cursor
-				// This ensures cursor and video start at the EXACT same time
+				// Only start cursor if native recording started successfully
 				if (success) {
 					const standardCursorOptions = {
 						videoRelative: true,
@@ -561,36 +560,11 @@ class MacRecorder extends EventEmitter {
 									  this.options.captureArea ? 'area' : 'display',
 						captureArea: this.options.captureArea,
 						windowId: this.options.windowId,
-						startTimestamp: sessionTimestamp // Will be updated with actual start time
+						startTimestamp: sessionTimestamp // Use the same timestamp base
 					};
 
 					try {
-						// Poll for actual recording start (when first frame is captured)
-						console.log('⏳ SYNC: Waiting for first video frame...');
-						const maxWaitMs = 2000; // Max 2 seconds wait
-						const pollInterval = 10; // Check every 10ms
-						let waitedMs = 0;
-						let actualStartTime = 0;
-						
-						while (waitedMs < maxWaitMs) {
-							actualStartTime = nativeBinding.getActualRecordingStartTime();
-							if (actualStartTime > 0) {
-								console.log(`✅ SYNC: First frame captured at ${actualStartTime}ms (waited ${waitedMs}ms)`);
-								break;
-							}
-							await new Promise(resolve => setTimeout(resolve, pollInterval));
-							waitedMs += pollInterval;
-						}
-						
-						if (actualStartTime > 0) {
-							// Use actual start time for perfect sync
-							standardCursorOptions.startTimestamp = actualStartTime;
-							console.log('🎯 SYNC: Starting cursor tracking at ACTUAL recording start:', actualStartTime);
-						} else {
-							// Fallback to session timestamp if first frame not detected
-							console.warn('⚠️ SYNC: First frame not detected, using session timestamp');
-						}
-						
+						console.log('🎯 SYNC: Starting cursor tracking at timestamp:', sessionTimestamp);
 						await this.startCursorCapture(cursorFilePath, standardCursorOptions);
 						console.log('✅ SYNC: Cursor tracking started successfully');
 					} catch (cursorError) {
@@ -1033,23 +1007,21 @@ class MacRecorder extends EventEmitter {
 
 		const last = this.lastCapturedData;
 
-		// Event type değişmişse (click, drag, vs)
+		// Event type değişmişse
 		if (currentData.type !== last.type) {
 			return true;
 		}
 
-		// Cursor type değişmişse (pointer, text, vs)
-		if (currentData.cursorType !== last.cursorType) {
+		// Pozisyon değişmişse (minimum 2 pixel tolerans)
+		if (
+			Math.abs(currentData.x - last.x) >= 2 ||
+			Math.abs(currentData.y - last.y) >= 2
+		) {
 			return true;
 		}
 
-		// SYNC FIX: Reduced threshold for better sync (1 pixel instead of 2)
-		// With 200 FPS sampling, we can afford more granular position tracking
-		// Pozisyon değişmişse (minimum 1 pixel - hassas tracking)
-		if (
-			Math.abs(currentData.x - last.x) >= 1 ||
-			Math.abs(currentData.y - last.y) >= 1
-		) {
+		// Cursor type değişmişse
+		if (currentData.cursorType !== last.cursorType) {
 			return true;
 		}
 
@@ -1070,14 +1042,11 @@ class MacRecorder extends EventEmitter {
 	 */
 	async startCursorCapture(intervalOrFilepath = 100, options = {}) {
 		let filepath;
-		// SYNC FIX: Use 5ms interval (200 FPS) for ultra-smooth cursor tracking
-		// This high sampling rate ensures cursor is always in sync with 60 FPS video
-		// Even if we sample 200 times per second, we only write on position/event changes (efficient)
-		let interval = 5; // Default 200 FPS for perfect sync
+		let interval = 20; // Default 50 FPS
 
 		// Parameter parsing: number = interval, string = filepath
 		if (typeof intervalOrFilepath === "number") {
-			interval = Math.max(5, intervalOrFilepath); // Min 5ms for sync
+			interval = Math.max(10, intervalOrFilepath); // Min 10ms
 			filepath = `cursor-data-${Date.now()}.json`;
 		} else if (typeof intervalOrFilepath === "string") {
 			filepath = intervalOrFilepath;
@@ -1172,10 +1141,6 @@ class MacRecorder extends EventEmitter {
 
 		return new Promise((resolve, reject) => {
 			try {
-				// NOTE: Native cursor tracking (NSTimer/CFRunLoop) doesn't work with Node.js event loop
-				// Using JavaScript setInterval with high frequency (5ms = 200 FPS) instead
-				// This provides excellent sync with minimal overhead due to change-detection filtering
-				
 				// Dosyayı oluştur ve temizle
 				const fs = require("fs");
 				fs.writeFileSync(filepath, "[");
@@ -1280,7 +1245,7 @@ class MacRecorder extends EventEmitter {
 					return resolve(false);
 				}
 
-				// Stop JavaScript interval
+				// Interval'ı durdur
 				clearInterval(this.cursorCaptureInterval);
 				this.cursorCaptureInterval = null;
 

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -25,9 +25,6 @@ static CMTime g_avStartTime;
 static void* g_avAudioRecorder = nil;
 static NSString* g_avAudioOutputPath = nil;
 
-// SYNC FIX: Track actual recording start time (when first frame is captured)
-static NSTimeInterval g_avActualRecordingStartTime = 0;
-
 // AVFoundation screen recording implementation
 extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                            CGDirectDisplayID displayID,
@@ -383,11 +380,6 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                 CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(((double)g_avFrameNumber) / fps, 600));
                                 BOOL appendSuccess = [localPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:frameTime];
                                 if (appendSuccess) {
-                                    // SYNC FIX: Record actual start time when first frame is written
-                                    if (g_avFrameNumber == 0) {
-                                        g_avActualRecordingStartTime = [[NSDate date] timeIntervalSince1970] * 1000; // milliseconds
-                                        MRLog(@"🎞️ AVFoundation first frame written (actual start time: %.0f)", g_avActualRecordingStartTime);
-                                    }
                                     g_avFrameNumber++;
                                 } else {
                                     NSLog(@"⚠️ Failed to append pixel buffer");
@@ -487,7 +479,6 @@ extern "C" bool stopAVFoundationRecording() {
         g_avVideoInput = nil;
         g_avPixelBufferAdaptor = nil;
         g_avFrameNumber = 0;
-        g_avActualRecordingStartTime = 0;
         
         MRLog(@"✅ AVFoundation recording stopped");
         return true;
@@ -502,11 +493,6 @@ extern "C" bool isAVFoundationRecording() {
     return g_avIsRecording;
 }
 
-// SYNC FIX: Get actual recording start time for AVFoundation
-extern "C" NSTimeInterval getAVFoundationActualStartTime() {
-    return g_avActualRecordingStartTime;
-}
-
 extern "C" NSString* getAVFoundationAudioPath() {
     return g_avAudioOutputPath;
 }

package/src/cursor_tracker.mm

@@ -1032,9 +1032,7 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
         // NSTimer kullan (main thread'de çalışır)
         g_timerTarget = [[CursorTimerTarget alloc] init];
         
-        // SYNC FIX: Match screen recording frame rate (60 FPS = 16.67ms)
-        // This ensures cursor tracking is synchronized with video frames
-        g_cursorTimer = [NSTimer timerWithTimeInterval:0.01667 // 16.67ms (60 FPS) - matches screen recording
+        g_cursorTimer = [NSTimer timerWithTimeInterval:0.05 // 50ms (20 FPS)
                                                 target:g_timerTarget
                                               selector:@selector(timerCallback:)
                                               userInfo:nil

package/src/mac_recorder.mm

@@ -23,7 +23,6 @@ extern "C" {
                                    double frameRate);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
-    NSTimeInterval getAVFoundationActualStartTime();
     NSString* getAVFoundationAudioPath();
 
     NSArray<NSDictionary *> *listCameraDevices();
@@ -1058,26 +1057,6 @@ Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(env, isRecording);
 }
 
-// SYNC FIX: Get actual recording start time (when first frame was captured)
-Napi::Value GetActualRecordingStartTime(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    NSTimeInterval startTime = 0;
-    
-    // Check ScreenCaptureKit first
-    if (@available(macOS 12.3, *)) {
-        startTime = [ScreenCaptureKitRecorder getActualRecordingStartTime];
-    }
-    
-    // Check AVFoundation if ScreenCaptureKit didn't return a time
-    if (startTime == 0) {
-        startTime = getAVFoundationActualStartTime();
-    }
-    
-    // Return 0 if not started yet, otherwise return the actual start time in milliseconds
-    return Napi::Number::New(env, startTime);
-}
-
 // NAPI Function: Get Window Thumbnail
 Napi::Value GetWindowThumbnail(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -1406,7 +1385,6 @@ 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, "getActualRecordingStartTime"), Napi::Function::New(env, GetActualRecordingStartTime));
     exports.Set(Napi::String::New(env, "checkPermissions"), Napi::Function::New(env, CheckPermissions));
     
     // Thumbnail functions

package/src/screen_capture_kit.h

@@ -15,6 +15,5 @@ API_AVAILABLE(macos(12.3))
 + (void)finalizeRecording;
 + (void)finalizeVideoWriter;
 + (void)cleanupVideoWriter;
-+ (NSTimeInterval)getActualRecordingStartTime;
 
 @end

package/src/screen_capture_kit.mm

@@ -38,9 +38,6 @@ static NSInteger g_targetFPS = 60;
 static NSInteger g_frameCount = 0;
 static CFAbsoluteTime g_firstFrameTime = 0;
 
-// SYNC FIX: Track actual recording start time (when first frame is captured)
-static NSTimeInterval g_actualRecordingStartTime = 0;
-
 static void CleanupWriters(void);
 static AVAssetWriterInputPixelBufferAdaptor * _Nullable CurrentPixelBufferAdaptor(void) {
     if (!g_pixelBufferAdaptorRef) {
@@ -102,7 +99,6 @@ static void CleanupWriters(void) {
         // Reset frame counting
         g_frameCount = 0;
         g_firstFrameTime = 0;
-        g_actualRecordingStartTime = 0;
     }
     
     if (g_audioWriter) {
@@ -194,12 +190,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         [g_videoWriter startSessionAtSourceTime:presentationTime];
         g_videoStartTime = presentationTime;
         g_videoWriterStarted = YES;
-        
-        // SYNC FIX: Record the ACTUAL recording start time (when first frame is captured)
-        // This is the TRUE sync point - cursor tracking should use this timestamp
-        g_actualRecordingStartTime = [[NSDate date] timeIntervalSince1970] * 1000; // milliseconds
-        MRLog(@"🎞️ Video writer session started @ %.3f (actual start time: %.0f)", 
-              CMTimeGetSeconds(presentationTime), g_actualRecordingStartTime);
+        MRLog(@"🎞️ Video writer session started @ %.3f", CMTimeGetSeconds(presentationTime));
     }
     
     if (!g_videoInput.readyForMoreMediaData) {
@@ -954,16 +945,9 @@ BOOL isScreenCaptureKitCleaningUp() API_AVAILABLE(macos(12.3)) {
         g_isRecording = NO;
         g_isCleaningUp = NO;  // Reset cleanup flag
         g_outputPath = nil;
-        g_actualRecordingStartTime = 0;
         
         MRLog(@"🧹 Pure ScreenCaptureKit cleanup complete");
     }
 }
 
-// SYNC FIX: Get the actual recording start time (when first frame was captured)
-// This is the TRUE sync point for cursor tracking
-+ (NSTimeInterval)getActualRecordingStartTime {
-    return g_actualRecordingStartTime;
-}
-
 @end

package/.cursor/worktrees.json

@@ -1,5 +0,0 @@
-{
-  "setup-worktree": [
-    "npm install"
-  ]
-}

package/CURSOR-SYNC-FIX.md

@@ -1,85 +0,0 @@
-# Cursor-Video Senkronizasyon Düzeltmesi
-
-## Problem
-Ekran videosu kaydedilirken custom cursor da kayıt ediliyor, ancak cursor'un tıklama/hareket kayıtları ekran videosundan ~0.5-1 saniye geriden geliyordu.
-
-## Çözüm
-
-### 1. Cursor Tracking Interval Azaltıldı
-- **Öncesi**: 20ms interval (50 FPS)
-- **Sonrası**: 5ms interval (200 FPS)
-- **Sonuç**: Cursor artık çok daha sık örnekleniyor, bu yüzden video frame'leri ile sync şansı çok daha yüksek
-
-### 2. Position Threshold Azaltıldı
-- **Öncesi**: 2 pixel minimum hareket
-- **Sonrası**: 1 pixel minimum hareket
-- **Sonuç**: Daha hassas tracking, küçük mouse hareketleri bile kaydediliyor
-
-### 3. Gerçek Test Sonuçları
-
-```
-📊 Cursor tracking analysis:
-   Total events captured: 193
-   Average capture rate: 41.5 FPS
-   Timing analysis:
-   - Average interval: 24.3ms (41.2 FPS)
-   - Min interval: 1.0ms
-   - Max interval: 765.0ms
-   ✅ Smooth cursor tracking
-```
-
-## Test Etme
-
-```bash
-# Kısa sync testi (5 saniye, mouse'u hareket ettir)
-node test-cursor-sync-mouse.js
-
-# Test sonrası video ve cursor dosyasını kontrol et:
-# - Video: test-output/sync-test-{timestamp}.mov
-# - Cursor: test-output/temp_cursor_{timestamp}.json
-```
-
-## Teknik Detaylar
-
-### Neden Native Event Tracking Kullanılmadı?
-Native `NSTimer` ve `CGEventTap` çalışıyor ama Node.js event loop ile uyumsuz. Timer callback'leri çağrılmıyor çünkü:
-- Node.js kendi event loop'unu kullanıyor
-- macOS main run loop block olmuyor
-- Bu yüzden timer callback'leri tetiklenmiyor
-
-### JavaScript Polling Neden Yeterli?
-- 5ms interval = 200 FPS sampling rate
-- Video 60 FPS = ~16.67ms per frame
-- Cursor her video frame'inde 3+ kez örnekleniyor
-- `shouldCaptureEvent` filtrelemesi sayesinde sadece değişiklikler kaydediliyor
-- Ortalama 40-50 FPS cursor data elde ediliyor (yeterli)
-
-### Sync Mekanizması
-1. **Unified Session Timestamp**: Hem video hem cursor aynı `sessionTimestamp` kullanıyor
-2. **Synchronized Start**: Video başladıktan hemen sonra cursor tracking başlıyor (aynı timestamp)
-3. **Relative Timestamps**: İkisi de başlangıçtan itibaren millisaniye cinsinden kaydediyor
-
-## Beklenen Sonuç
-
-- ✅ Cursor ve video aynı anda başlıyor (0ms fark)
-- ✅ Cursor her ~24ms'de bir örnekleniyor (smooth)
-- ✅ Click event'leri doğru yakalanıyor
-- ✅ Video frame'leri ile mükemmel sync
-
-## Ek Notlar
-
-### Çoklu Ekran Kullanımı
-Eğer cursor başka bir ekrandaysa `coordinateSystem: "video-relative-outside"` olarak işaretlenir. Bu normal ve cursor overlay render'ında handle edilmelidir.
-
-### Performance
-200 FPS sampling yüksek görünse de:
-- Change detection filtrelemesi var (sadece hareket olunca yazıyor)
-- Dosya boyutu küçük kalıyor
-- CPU overhead minimal
-
-### İleride İyileştirme
-Native event tracking için:
-- Ayrı thread'de CFRunLoop çalıştırılabilir
-- Veya GCD dispatch queue kullanılabilir
-- Ama şimdilik JavaScript polling yeterli ve güvenilir
-

package/CURSOR-SYNC-PERFECT.md

@@ -1,138 +0,0 @@
-# ✅ Cursor-Video Senkronizasyon Tamamen Çözüldü!
-
-## Asıl Sorun
-
-Cursor tracking **hemen** başlıyordu, ama video'nun ilk frame'ini yakalaması **~100-200ms** sürüyordu.
-
-```
-ÖNCE:
-t=0ms:    startRecording() çağrılır
-t=0ms:    Cursor tracking başlar ✅
-t=150ms:  İlk video frame yakalanır ❌ (CURSOR ÖNDE!)
-```
-
-Bu yüzden cursor event'leri video'dan önce geliyordu - **cursor önde, video geride!**
-
-## Çözüm: İlk Frame Senkronizasyonu
-
-### 1. Native Tarafta: İlk Frame Timestamp'ini Kaydet
-
-**ScreenCaptureKit** (`screen_capture_kit.mm`):
-```objc
-static NSTimeInterval g_actualRecordingStartTime = 0;
-
-- (void)stream:didOutputSampleBuffer:ofType: {
-    if (!g_videoWriterStarted) {
-        // İlk frame yakalandığında
-        g_actualRecordingStartTime = [[NSDate date] timeIntervalSince1970] * 1000;
-        MRLog(@"🎞️ First frame captured at %.0f", g_actualRecordingStartTime);
-    }
-}
-```
-
-**AVFoundation** (`avfoundation_recorder.mm`):
-```objc
-static NSTimeInterval g_avActualRecordingStartTime = 0;
-
-if (g_avFrameNumber == 0) {
-    // İlk frame yazıldığında
-    g_avActualRecordingStartTime = [[NSDate date] timeIntervalSince1970] * 1000;
-    MRLog(@"🎞️ AVFoundation first frame written at %.0f", g_avActualRecordingStartTime);
-}
-```
-
-### 2. JavaScript Tarafta: İlk Frame'i Bekle
-
-```javascript
-// Poll for actual recording start (when first frame is captured)
-console.log('⏳ SYNC: Waiting for first video frame...');
-const maxWaitMs = 2000;
-const pollInterval = 10;
-let actualStartTime = 0;
-
-while (waitedMs < maxWaitMs) {
-    actualStartTime = nativeBinding.getActualRecordingStartTime();
-    if (actualStartTime > 0) {
-        console.log(`✅ SYNC: First frame captured at ${actualStartTime}ms`);
-        break;
-    }
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
-    waitedMs += pollInterval;
-}
-
-// Cursor tracking'i ACTUAL start time ile başlat
-await this.startCursorCapture(cursorFilePath, {
-    startTimestamp: actualStartTime  // ← PERFECT SYNC!
-});
-```
-
-## Sonuç: Mükemmel Senkronizasyon!
-
-```
-ŞIMDI:
-t=0ms:    startRecording() çağrılır
-t=150ms:  İlk video frame yakalanır ✅
-t=150ms:  Cursor tracking başlar ✅ (TAM SENKRON!)
-```
-
-### Test Sonuçları:
-```
-✅ SYNC: First frame captured at 1761818226539.994ms (waited 30ms)
-🎯 SYNC: Starting cursor tracking at ACTUAL recording start: 1761818226539.994
-   First cursor event: t=19.006ms (video'dan 19ms sonra - mükemmel!)
-```
-
-## Teknik Detaylar
-
-### Neden Bu Yaklaşım Çalışıyor?
-
-1. **Video recording başlatma** → Native sistem hazırlanıyor
-2. **İlk frame yakalanıyor** → GERÇEK kayıt başlangıcı (100-200ms sonra)
-3. **Cursor tracking başlıyor** → Aynı timestamp'ten başlıyor
-4. **Sonuç**: Cursor ve video TAM SENKRON!
-
-### Timing Analizi
-
-- **Bekleme süresi**: ~30ms (çok hızlı!)
-- **İlk cursor event**: İlk frame'den 19ms sonra
-- **Senkronizasyon farkı**: <20ms (algılanamaz!)
-
-### Ek İyileştirmeler
-
-1. **5ms cursor interval** (200 FPS sampling)
-2. **1px minimum threshold** (hassas tracking)
-3. **Change detection filtering** (sadece hareket varsa kaydet)
-
-## Test Etme
-
-```bash
-node test-cursor-sync-mouse.js
-```
-
-Test sırasında mouse'u hareket ettir ve tıkla. Sonuçta:
-- ✅ Video ve cursor aynı anda başlıyor
-- ✅ Tıklama event'leri doğru timing'de
-- ✅ Mouse hareketi smooth ve senkronize
-
-## Kullanım
-
-```javascript
-const recorder = new MacRecorder();
-
-// Normal kullanım - senkronizasyon otomatik!
-await recorder.startRecording('output.mov', {
-    captureCursor: false, // Sistem cursor'unu gizle
-    frameRate: 60
-});
-
-// Cursor tracking otomatik olarak video'nun ilk frame'ini bekler
-// ve mükemmel senkronizasyonla başlar!
-```
-
-## Özet
-
-🎯 **Problem Çözüldü**: Cursor artık video ile TAM SENKRONIZE!
-✅ **Timing**: İlk frame'den <20ms sonra cursor tracking başlıyor
-⚡ **Performance**: Sadece ~30ms bekleme süresi
-🔥 **Sonuç**: Mükemmel cursor-video sync!
-