node-mac-recorder 2.21.32 → 2.21.34

package/.claude/settings.local.json

@@ -1,15 +1,9 @@
 {
   "permissions": {
     "allow": [
-      "Bash(ffmpeg:*)",
-      "Bash(chmod:*)",
-      "Bash(node test-sync.js:*)",
-      "Bash(node:*)",
-      "Bash(ALLOW_CONTINUITY_CAMERA=1 node:*)",
-      "Bash(awk:*)",
-      "Bash(ffprobe:*)",
-      "Bash(sw_vers:*)",
-      "Bash(system_profiler:*)"
+      "Bash(cat:*)",
+      "Bash(pkill:*)",
+      "Bash(for f in test-output/*1761946670140.mov)"
     ],
     "deny": [],
     "ask": []

package/canvas-player.html

@@ -347,6 +347,22 @@
 					cursor: true
 				};
 
+				// SYNC FIX: Track video durations for sync compensation
+				this.videoDurations = {
+					screen: 0,
+					camera: 0,
+					audio: 0
+				};
+				this.maxDuration = 0;
+				this.cameraStartOffset = 0; // Time offset for camera sync
+				this.cameraAvailableUntil = 0; // Absolute time (s) where camera footage ends on master timeline
+				this.cameraEndGap = 0; // How much camera ends before master
+				this.mediaLoaded = {
+					screen: false,
+					camera: false,
+					audio: false
+				};
+
 				// SYNC FIX: Ensure all videos have same playback settings
 				[this.screenVideo, this.cameraVideo, this.audioVideo].forEach(video => {
 					video.playbackRate = 1.0;
@@ -362,12 +378,14 @@
 					const response = await fetch('test-output/recording-metadata.json');
 					this.metadata = await response.json();
 
-					this.displayInfo();
 					this.showLayerControls();
 
 					// Load videos
 					await this.loadVideos();
 
+					// Update info after media durations are known
+					this.displayInfo();
+
 					// Load cursor data
 					if (this.metadata.files.cursor) {
 						await this.loadCursorData();
@@ -418,6 +436,16 @@
 
 					console.log('✅ All videos loaded and ready for playback');
 
+					this.mediaLoaded.screen = screenLoaded;
+					this.mediaLoaded.camera = cameraLoaded;
+					this.mediaLoaded.audio = audioLoaded;
+
+					this.videoDurations.screen = screenLoaded ? (this.screenVideo.duration || 0) : 0;
+					this.videoDurations.camera = cameraLoaded ? (this.cameraVideo.duration || 0) : 0;
+					this.videoDurations.audio = audioLoaded ? (this.audioVideo.duration || 0) : 0;
+
+					this.calculateSyncOffsets();
+
 					// SYNC FIX: Set all videos to frame 0 and wait for seek complete
 					const seekToStart = (video) => {
 						return new Promise(resolve => {
@@ -448,6 +476,95 @@
 				}
 			}
 
+			calculateSyncOffsets() {
+				const tolerance = 0.1; // seconds
+
+				const screenDuration = this.videoDurations.screen || 0;
+				const cameraDuration = this.videoDurations.camera || 0;
+				const audioDuration = this.videoDurations.audio || 0;
+
+				console.log('📏 Media durations (s):', {
+					screen: screenDuration ? screenDuration.toFixed(2) : '—',
+					camera: cameraDuration ? cameraDuration.toFixed(2) : '—',
+					audio: audioDuration ? audioDuration.toFixed(2) : '—'
+				});
+
+				// Reset derived sync state
+				this.cameraStartOffset = 0;
+				this.cameraAvailableUntil = cameraDuration;
+				this.cameraEndGap = 0;
+
+				// Choose a sensible master duration (screen dominates, then audio, then camera)
+				const candidateDurations = [
+					screenDuration,
+					audioDuration,
+					cameraDuration
+				].filter(value => value && value > 0);
+
+				this.maxDuration = candidateDurations.length > 0 ? Math.max(...candidateDurations) : 0;
+
+				const audioMatchesScreen =
+					screenDuration > 0 && audioDuration > 0 && Math.abs(audioDuration - screenDuration) <= tolerance;
+
+				if (cameraDuration > 0) {
+					let explained = false;
+
+					if (screenDuration > 0) {
+						const cameraVsScreen = screenDuration - cameraDuration;
+
+						if (cameraVsScreen > tolerance) {
+							// Screen is longer than camera. Only treat this as a late camera start
+							// when audio corroborates the screen duration or camera is the outlier.
+							const cameraVsAudio = audioDuration > 0 ? Math.abs(audioDuration - cameraDuration) : Infinity;
+							const screenVsAudio = audioDuration > 0 ? Math.abs(audioDuration - screenDuration) : Infinity;
+							const audioSupportsScreen = audioMatchesScreen || screenVsAudio <= cameraVsAudio;
+
+							if (audioSupportsScreen) {
+								this.cameraStartOffset = cameraVsScreen;
+								this.cameraAvailableUntil = this.cameraStartOffset + cameraDuration;
+								explained = true;
+								console.log('⚖️ Camera appears to start late by', (this.cameraStartOffset * 1000).toFixed(0), 'ms');
+							}
+						} else if (cameraVsScreen < -tolerance) {
+							// Camera is longer than screen – we do not support negative offsets yet.
+							this.cameraAvailableUntil = cameraDuration;
+							console.log('ℹ️ Camera duration exceeds screen by', Math.abs(cameraVsScreen * 1000).toFixed(0), 'ms; leaving offset at 0');
+							explained = true;
+						}
+					}
+
+					if (!explained) {
+						// Either no screen video or difference is negligible – camera aligns to master at t=0
+						this.cameraAvailableUntil = cameraDuration;
+					}
+				}
+
+				// Determine how far the camera footage extends on the master timeline
+				if (this.cameraAvailableUntil > 0) {
+					this.cameraAvailableUntil = Math.max(this.cameraAvailableUntil, cameraDuration);
+				}
+
+				const masterCandidates = [
+					this.maxDuration,
+					this.cameraAvailableUntil,
+					screenDuration,
+					audioDuration
+				].filter(value => value && value > 0);
+
+				this.maxDuration = masterCandidates.length > 0 ? Math.max(...masterCandidates) : 0;
+
+				if (this.maxDuration > 0 && this.cameraAvailableUntil > 0) {
+					this.cameraEndGap = this.maxDuration - this.cameraAvailableUntil;
+					if (this.cameraEndGap < tolerance) {
+						this.cameraEndGap = 0;
+					} else {
+						console.log('ℹ️ Camera footage ends', this.cameraEndGap.toFixed(2), 's before master timeline');
+					}
+				} else {
+					this.cameraEndGap = 0;
+				}
+			}
+
 			async loadCursorData() {
 				try {
 					const response = await fetch('test-output/' + this.metadata.files.cursor);
@@ -544,7 +661,11 @@
 				const targetTime = this.pausedTime / 1000;
 				this.screenVideo.currentTime = targetTime;
 				if (this.metadata.files.camera && this.cameraVideo.readyState >= 2) {
-					this.cameraVideo.currentTime = targetTime;
+					const cameraDuration = this.cameraVideo.duration || this.videoDurations.camera || 0;
+					const cameraTarget = Math.max(0, targetTime - this.cameraStartOffset);
+					this.cameraVideo.currentTime = cameraDuration > 0
+						? Math.min(cameraTarget, cameraDuration)
+						: cameraTarget;
 				}
 				if (this.metadata.files.audio && this.audioVideo.readyState >= 2) {
 					this.audioVideo.currentTime = targetTime;
@@ -606,18 +727,24 @@
 			}
 
 			async seek(percent) {
-				const time = this.screenVideo.duration * percent;
+				const masterDuration = this.screenVideo.duration || this.maxDuration || 0;
+				const time = masterDuration * percent;
+				const screenTarget = Math.min(time, this.screenVideo.duration || time);
 
 				// SYNC FIX: Set all video times simultaneously
 				const seekPromises = [];
 
-				this.screenVideo.currentTime = time;
+				this.screenVideo.currentTime = screenTarget;
 				seekPromises.push(new Promise(resolve => {
 					this.screenVideo.onseeked = resolve;
 				}));
 
 				if (this.metadata.files.camera) {
-					this.cameraVideo.currentTime = time;
+					const cameraDuration = this.cameraVideo.duration || this.videoDurations.camera || 0;
+					const cameraTarget = Math.max(0, time - this.cameraStartOffset);
+					this.cameraVideo.currentTime = cameraDuration > 0
+						? Math.min(cameraTarget, cameraDuration)
+						: cameraTarget;
 					seekPromises.push(new Promise(resolve => {
 						this.cameraVideo.onseeked = resolve;
 					}));
@@ -638,13 +765,13 @@
 					console.warn('⚠️ Seek error:', error);
 				}
 
-				this.pausedTime = time * 1000;
+				this.pausedTime = screenTarget * 1000;
 				if (this.isPlaying) {
 					this.startTime = performance.now() - this.pausedTime;
 				}
 
 				// Update cursor
-				this.updateCursor(time * 1000);
+				this.updateCursor(screenTarget * 1000);
 			}
 
 			animate() {
@@ -681,28 +808,46 @@
 				const syncThreshold = 30; // 30ms tolerance (very tight sync)
 				const masterSeconds = masterTime / 1000;
 
-				// Sync camera video
+				// Sync camera video with offset compensation
 				if (this.metadata.files.camera && this.cameraVideo.readyState >= 2 && !this.cameraVideo.paused) {
-					const cameraDiff = Math.abs(this.cameraVideo.currentTime * 1000 - masterTime);
-					if (cameraDiff > syncThreshold) {
-						// SYNC FIX: Adjust playback rate temporarily for smoother sync
-						if (cameraDiff > 200) {
-							// Large drift - hard sync
-							this.cameraVideo.currentTime = masterSeconds;
-							console.log('🎥 Camera hard sync:', cameraDiff.toFixed(0) + 'ms → ' + masterSeconds.toFixed(2) + 's');
-						} else if (cameraDiff > syncThreshold) {
-							// Small drift - soft sync with playback rate adjustment
-							if (this.cameraVideo.currentTime > masterSeconds) {
-								this.cameraVideo.playbackRate = 0.95; // Slow down
-							} else {
-								this.cameraVideo.playbackRate = 1.05; // Speed up
-							}
-							// Reset playback rate after correction
-							setTimeout(() => {
-								if (this.cameraVideo) {
-									this.cameraVideo.playbackRate = 1.0;
+					const cameraStart = this.cameraStartOffset || 0;
+					const cameraDuration = this.cameraVideo.duration || this.videoDurations.camera || 0;
+					const adjustedMasterTime = masterSeconds - cameraStart;
+
+					// Before camera start - keep it parked at frame 0
+					if (adjustedMasterTime < -0.05) {
+						if (this.cameraVideo.currentTime > 0.05) {
+							this.cameraVideo.currentTime = 0;
+						}
+						return;
+					}
+
+					// After camera footage ends - nothing to sync
+					if (cameraDuration > 0 && adjustedMasterTime > cameraDuration + 0.05) {
+						return;
+					}
+
+					// Keep within valid playback range
+					const targetTime = Math.max(0, Math.min(adjustedMasterTime, cameraDuration || adjustedMasterTime));
+
+					if (cameraDuration > 0) {
+						const cameraDiff = Math.abs(this.cameraVideo.currentTime - targetTime) * 1000;
+						if (cameraDiff > syncThreshold) {
+							if (cameraDiff > 200) {
+								this.cameraVideo.currentTime = targetTime;
+								console.log('🎥 Camera hard sync:', cameraDiff.toFixed(0) + 'ms → ' + targetTime.toFixed(2) + 's');
+							} else if (cameraDiff > syncThreshold) {
+								if (this.cameraVideo.currentTime > targetTime) {
+									this.cameraVideo.playbackRate = 0.95;
+								} else {
+									this.cameraVideo.playbackRate = 1.05;
 								}
-							}, 500);
+								setTimeout(() => {
+									if (this.cameraVideo) {
+										this.cameraVideo.playbackRate = 1.0;
+									}
+								}, 500);
+							}
 						}
 					}
 				}
@@ -744,21 +889,48 @@
 					this.ctx.drawImage(this.screenVideo, 0, 0, this.canvas.width, this.canvas.height);
 				}
 
-				// Draw camera video overlay (layer 2)
+				// Draw camera video overlay (layer 2) with offset compensation
 				if (this.layers.camera && this.metadata.files.camera && this.cameraVideo.readyState >= 2) {
+					// SYNC FIX: Apply camera start offset
+					const timeInSeconds = currentTime / 1000;
 					const cameraWidth = 240;
 					const cameraHeight = 180;
 					const padding = 20;
 					const x = this.canvas.width - cameraWidth - padding;
 					const y = this.canvas.height - cameraHeight - padding;
+					const cameraDuration = this.videoDurations.camera || (this.cameraVideo.duration || 0);
+					const cameraStart = this.cameraStartOffset || 0;
+					const cameraEnd = this.cameraAvailableUntil > 0
+						? this.cameraAvailableUntil
+						: cameraStart + cameraDuration;
+					const beforeStart = timeInSeconds + 0.05 < cameraStart; // small tolerance
+					const afterEnd = cameraDuration > 0 && timeInSeconds - 0.05 > cameraEnd;
+
+					const drawPlaceholder = (message, border = '#666') => {
+						this.ctx.strokeStyle = border;
+						this.ctx.lineWidth = 3;
+						this.ctx.strokeRect(x - 2, y - 2, cameraWidth + 4, cameraHeight + 4);
+						this.ctx.fillStyle = '#333';
+						this.ctx.fillRect(x, y, cameraWidth, cameraHeight);
+						if (message) {
+							this.ctx.fillStyle = '#999';
+							this.ctx.font = '14px sans-serif';
+							this.ctx.textAlign = 'center';
+							this.ctx.textBaseline = 'middle';
+							this.ctx.fillText(message, x + cameraWidth / 2, y + cameraHeight / 2);
+						}
+					};
 
-					// Draw border
-					this.ctx.strokeStyle = '#4a9eff';
-					this.ctx.lineWidth = 3;
-					this.ctx.strokeRect(x - 2, y - 2, cameraWidth + 4, cameraHeight + 4);
-
-					// Draw camera video
-					this.ctx.drawImage(this.cameraVideo, x, y, cameraWidth, cameraHeight);
+					if (beforeStart) {
+						drawPlaceholder('Camera Starting...');
+					} else if (afterEnd) {
+						drawPlaceholder('Camera Finished', '#555');
+					} else {
+						this.ctx.strokeStyle = '#4a9eff';
+						this.ctx.lineWidth = 3;
+						this.ctx.strokeRect(x - 2, y - 2, cameraWidth + 4, cameraHeight + 4);
+						this.ctx.drawImage(this.cameraVideo, x, y, cameraWidth, cameraHeight);
+					}
 				}
 			}
 
@@ -813,7 +985,8 @@
 			}
 
 			updateProgress(masterTime) {
-				const duration = this.screenVideo.duration * 1000;
+				// SYNC FIX: Use maxDuration for accurate timeline
+				const duration = (this.maxDuration || this.screenVideo.duration) * 1000;
 				const percent = (masterTime / duration) * 100;
 
 				document.getElementById('progressFill').style.width = Math.min(100, percent) + '%';
@@ -832,20 +1005,41 @@
 			}
 
 			displayInfo() {
+				// Build duration display with offset info if present
+				let durationDisplay = this.maxDuration > 0
+					? `${this.maxDuration.toFixed(1)}s`
+					: 'Unknown';
+
+				const offsetMs = Math.round(this.cameraStartOffset * 1000);
+				const earlyStopMs = Math.round(this.cameraEndGap * 1000);
+
+				if (offsetMs > 100) {
+					durationDisplay += ` (Camera +${offsetMs}ms offset)`;
+				}
+
+				if (earlyStopMs > 100) {
+					durationDisplay += ` (Camera ends ${earlyStopMs}ms early)`;
+				}
+
+				const statusIcon = (expected, loaded) => {
+					if (!expected) return '❌';
+					return loaded ? '✅' : '⚠️';
+				};
+
 				const infoHtml = `
 					<div class="info">
 						<div class="info-grid">
 							<div class="info-item">
 								<span class="info-label">🖥️ Screen:</span>
-								<span class="info-value">${this.metadata.files.screen ? '✅' : '❌'}</span>
+								<span class="info-value">${statusIcon(this.metadata.files.screen, this.mediaLoaded.screen)}</span>
 							</div>
 							<div class="info-item">
 								<span class="info-label">📹 Camera:</span>
-								<span class="info-value">${this.metadata.files.camera ? '✅' : '❌'}</span>
+								<span class="info-value">${statusIcon(this.metadata.files.camera, this.mediaLoaded.camera)}</span>
 							</div>
 							<div class="info-item">
 								<span class="info-label">🎙️ Audio:</span>
-								<span class="info-value">${this.metadata.files.audio ? '✅' : '❌'}</span>
+								<span class="info-value">${statusIcon(this.metadata.files.audio, this.mediaLoaded.audio)}</span>
 							</div>
 							<div class="info-item">
 								<span class="info-label">🖱️ Cursor:</span>
@@ -853,7 +1047,7 @@
 							</div>
 							<div class="info-item">
 								<span class="info-label">⏱️ Duration:</span>
-								<span class="info-value">${this.metadata.duration}s</span>
+								<span class="info-value">${durationDisplay}</span>
 							</div>
 							<div class="info-item">
 								<span class="info-label">🎞️ Frame Rate:</span>
@@ -861,7 +1055,7 @@
 							</div>
 							<div class="info-item">
 								<span class="info-label">🔄 Sync Mode:</span>
-								<span class="info-value">Master-Slave (30ms) + Adaptive Rate</span>
+								<span class="info-value">Master-Slave (30ms) + Adaptive Rate + Offset</span>
 							</div>
 						</div>
 					</div>

package/index.js

@@ -784,6 +784,11 @@ class MacRecorder extends EventEmitter {
 		}
 
 		return new Promise(async (resolve, reject) => {
+			const stopRequestedAt = Date.now();
+			const elapsedSeconds =
+				this.recordingStartTime && this.recordingStartTime > 0
+					? (stopRequestedAt - this.recordingStartTime) / 1000
+					: -1;
 			try {
 				console.log('🛑 SYNC: Stopping all recording components simultaneously');
 
@@ -804,7 +809,8 @@ class MacRecorder extends EventEmitter {
 				// 2. Stop native screen recording
 				try {
 					console.log('🛑 SYNC: Stopping screen recording');
-					success = nativeBinding.stopRecording();
+					const stopLimit = elapsedSeconds > 0 ? elapsedSeconds : 0;
+					success = nativeBinding.stopRecording(stopLimit);
 					if (success) {
 						console.log('✅ SYNC: Screen recording stopped');
 					}

package/package.json

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

package/src/audio_recorder.mm

@@ -264,13 +264,20 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
             dispatch_semaphore_signal(semaphore);
         }];
 
-        // Reduced timeout to 1 second for external devices
-        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC));
+        // SYNC FIX: Match camera timeout (3 seconds) for consistent finish timing
+        const int64_t primaryWaitSeconds = 3;
+        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(primaryWaitSeconds * NSEC_PER_SEC));
         long result = dispatch_semaphore_wait(semaphore, timeout);
 
         if (result != 0 || !finished) {
-            MRLog(@"⚠️ AudioRecorder: Timed out waiting for writer (external device?) - forcing cancel");
-            // Force cancel if timeout
+            MRLog(@"⚠️ AudioRecorder: Writer still finishing after %ds – waiting longer", (int)primaryWaitSeconds);
+            const int64_t extendedWaitSeconds = 5;
+            dispatch_time_t extendedTimeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(extendedWaitSeconds * NSEC_PER_SEC));
+            result = dispatch_semaphore_wait(semaphore, extendedTimeout);
+        }
+
+        if (result != 0 || !finished) {
+            MRLog(@"⚠️ AudioRecorder: Writer did not finish after extended wait – forcing cancel");
             [self.writer cancelWriting];
         } else {
             MRLog(@"✅ AudioRecorder writer finished successfully");
@@ -333,6 +340,9 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
     CMItemCount timingEntryCount = 0;
     OSStatus timingStatus = CMSampleBufferGetSampleTimingInfoArray(sampleBuffer, 0, NULL, &timingEntryCount);
     CMSampleTimingInfo *timingInfo = NULL;
+    double stopLimit = MRSyncGetStopLimitSeconds();
+    double audioTolerance = 0.02;
+    BOOL shouldDropBuffer = NO;
     
     if (timingStatus == noErr && timingEntryCount > 0) {
         timingInfo = (CMSampleTimingInfo *)malloc(sizeof(CMSampleTimingInfo) * timingEntryCount);
@@ -348,6 +358,15 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
                             adjustedPTS = kCMTimeZero;
                         }
                         timingInfo[i].presentationTimeStamp = adjustedPTS;
+                        
+                        if (stopLimit > 0) {
+                            double sampleStart = CMTimeGetSeconds(adjustedPTS);
+                            double sampleDuration = CMTIME_IS_VALID(timingInfo[i].duration) ? CMTimeGetSeconds(timingInfo[i].duration) : 0.0;
+                            if (sampleStart > stopLimit + audioTolerance ||
+                                (sampleDuration > 0.0 && (sampleStart + sampleDuration) > stopLimit + audioTolerance)) {
+                                shouldDropBuffer = YES;
+                            }
+                        }
                     } else {
                         timingInfo[i].presentationTimeStamp = kCMTimeZero;
                     }
@@ -376,6 +395,24 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
             timingInfo = NULL;
         }
     }
+
+    if (stopLimit > 0 && !shouldDropBuffer && bufferToAppend == sampleBuffer) {
+        // No timing info available; approximate using buffer timestamp.
+        CMTime pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+        if (CMTIME_IS_VALID(pts)) {
+            double relativeStart = CMTimeGetSeconds(CMTimeSubtract(pts, self.startTime));
+            if (relativeStart > stopLimit + audioTolerance) {
+                shouldDropBuffer = YES;
+            }
+        }
+    }
+
+    if (shouldDropBuffer) {
+        if (bufferToAppend != sampleBuffer) {
+            CFRelease(bufferToAppend);
+        }
+        return;
+    }
     
     if (![self.writerInput appendSampleBuffer:bufferToAppend]) {
         NSLog(@"⚠️ Failed appending audio buffer: %@", self.writer.error);

package/src/avfoundation_recorder.mm

@@ -80,6 +80,16 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         // CRITICAL FIX: Use actual captured image dimensions for pixel buffer
         // CGDisplayCreateImage returns physical pixels on Retina displays
         CGImageRef testImage = CGDisplayCreateImage(displayID);
+        if (!testImage) {
+            NSLog(@"❌ AVFoundation: Failed to create display image for displayID %u", displayID);
+            NSLog(@"   Display may be invalid. Retrying with main display...");
+            displayID = CGMainDisplayID();
+            testImage = CGDisplayCreateImage(displayID);
+            if (!testImage) {
+                NSLog(@"❌ AVFoundation: Failed to create image even for main display");
+                return false;
+            }
+        }
         CGSize actualImageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
         CGImageRelease(testImage);
         
@@ -397,6 +407,22 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                 }
                                 CMTime presentationTime = CMTimeMakeWithSeconds(CMTimeGetSeconds(relativeTime), 600);
 
+                                double stopLimit = MRSyncGetStopLimitSeconds();
+                                if (stopLimit > 0) {
+                                    double secondsFromStart = CMTimeGetSeconds(presentationTime);
+                                    double tolerance = fps > 0 ? (1.5 / fps) : 0.02;
+                                    if (tolerance < 0.02) {
+                                        tolerance = 0.02;
+                                    }
+                                    if (secondsFromStart > stopLimit + tolerance) {
+                                        MRLog(@"⏹️ Screen frame skipped at %.3fs (limit %.3fs)", secondsFromStart, stopLimit);
+                                        CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+                                        CVPixelBufferRelease(pixelBuffer);
+                                        CGImageRelease(screenImage);
+                                        return;
+                                    }
+                                }
+
                                 BOOL appendSuccess = [localPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:presentationTime];
                                 if (appendSuccess) {
                                     g_avFrameNumber++;

package/src/camera_recorder.mm

@@ -90,6 +90,7 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 @property (nonatomic, assign) int32_t expectedHeight;
 @property (nonatomic, assign) double expectedFrameRate;
 @property (atomic, assign) BOOL needsReconfiguration;
+@property (nonatomic, strong) NSMutableArray<NSValue *> *pendingSampleBuffers;
 
 + (instancetype)sharedRecorder;
 + (NSArray<NSDictionary *> *)availableCameraDevices;
@@ -102,6 +103,14 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 
 @implementation CameraRecorder
 
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _pendingSampleBuffers = [NSMutableArray array];
+    }
+    return self;
+}
+
 + (instancetype)sharedRecorder {
     static CameraRecorder *recorder = nil;
     static dispatch_once_t onceToken;
@@ -256,6 +265,22 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     return devicesInfo;
 }
 
+- (void)clearPendingSampleBuffers {
+    id container = self.pendingSampleBuffers;
+    if (![container isKindOfClass:[NSArray class]]) {
+        MRLog(@"⚠️ CameraRecorder: pendingSampleBuffers corrupted (%@) — resetting", NSStringFromClass([container class]));
+        self.pendingSampleBuffers = [NSMutableArray array];
+        return;
+    }
+    for (NSValue *value in (NSArray *)container) {
+        CMSampleBufferRef buffer = (CMSampleBufferRef)[value pointerValue];
+        if (buffer) {
+            CFRelease(buffer);
+        }
+    }
+    [self.pendingSampleBuffers removeAllObjects];
+}
+
 - (void)resetState {
     self.writerStarted = NO;
     self.isRecording = NO;
@@ -269,6 +294,7 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     self.pixelBufferAdaptor = nil;
     self.outputPath = nil;
     self.captureQueue = nil;
+    [self clearPendingSampleBuffers];
 }
 
 - (AVCaptureDevice *)deviceForId:(NSString *)deviceId {
@@ -600,6 +626,7 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         MRLog(@"⚠️ CameraRecorder: Failed to remove existing camera file: %@", removeError);
     }
     
+    [self clearPendingSampleBuffers];
     AVCaptureDevice *device = [self deviceForId:deviceId];
     if (!device) {
         if (error) {
@@ -719,6 +746,21 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         return YES;
     }
 
+    // Delay stop slightly so camera ends close to audio length.
+    // Tunable via env var CAMERA_TAIL_SECONDS (default 0.11s)
+    NSTimeInterval cameraTailSeconds = 1.7;
+    const char *tailEnv = getenv("CAMERA_TAIL_SECONDS");
+    if (tailEnv) {
+        double parsed = atof(tailEnv);
+        if (parsed >= 0.0 && parsed <= 1.0) {
+            cameraTailSeconds = parsed;
+        }
+    }
+    MRLog(@"⏳ CameraRecorder: Delaying stop by %.3fs for tail capture", cameraTailSeconds);
+    if (cameraTailSeconds > 0) {
+        [NSThread sleepForTimeInterval:cameraTailSeconds];
+    }
+
     // CRITICAL FIX: For external cameras (especially Continuity Camera/iPhone),
     // stopRunning can hang if device is disconnected. Use async approach.
     MRLog(@"🛑 CameraRecorder: Stopping session (external device safe)...");
@@ -814,24 +856,101 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     return success;
 }
 
-- (void)captureOutput:(AVCaptureOutput *)output
- didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
-        fromConnection:(AVCaptureConnection *)connection {
-    if (!self.isRecording) {
+- (void)enqueueSampleBuffer:(CMSampleBufferRef)sampleBuffer {
+    if (!sampleBuffer) {
         return;
     }
+    if (![self.pendingSampleBuffers isKindOfClass:[NSMutableArray class]]) {
+        MRLog(@"⚠️ CameraRecorder: pendingSampleBuffers not NSMutableArray (%@) — reinitializing",
+              NSStringFromClass([self.pendingSampleBuffers class]));
+        self.pendingSampleBuffers = [NSMutableArray array];
+    }
+    CMSampleBufferRef bufferCopy = NULL;
+    OSStatus status = CMSampleBufferCreateCopy(kCFAllocatorDefault, sampleBuffer, &bufferCopy);
+    if (status == noErr && bufferCopy) {
+        [self.pendingSampleBuffers addObject:[NSValue valueWithPointer:bufferCopy]];
+    } else if (bufferCopy) {
+        CFRelease(bufferCopy);
+    }
+}
 
-    if (!sampleBuffer) {
+- (void)flushPendingSampleBuffers {
+    id container = self.pendingSampleBuffers;
+    if (![container isKindOfClass:[NSArray class]]) {
+        MRLog(@"⚠️ CameraRecorder: pendingSampleBuffers corrupted (%@) — resetting",
+              NSStringFromClass([container class]));
+        self.pendingSampleBuffers = [NSMutableArray array];
+        return;
+    }
+    if ([(NSArray *)container count] == 0) {
         return;
     }
 
-    CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+    NSArray<NSValue *> *queued = [(NSArray *)container copy];
+    [self.pendingSampleBuffers removeAllObjects];
 
-    // If audio is expected but not yet flowing, hold video frames to keep timeline aligned.
-    if (MRSyncShouldHoldVideoFrame(timestamp)) {
+    CMTime audioStart = MRSyncAudioFirstTimestamp();
+    BOOL hasAudioStart = CMTIME_IS_VALID(audioStart);
+
+    double stopLimit = MRSyncGetStopLimitSeconds();
+
+    for (NSValue *value in queued) {
+        CMSampleBufferRef buffer = (CMSampleBufferRef)[value pointerValue];
+        if (!buffer) {
+            continue;
+        }
+
+        CMTime bufferTime = CMSampleBufferGetPresentationTimeStamp(buffer);
+        if (hasAudioStart && CMTIME_IS_VALID(bufferTime)) {
+            // Drop frames captured before audio actually began to keep durations aligned.
+            if (CMTIME_COMPARE_INLINE(bufferTime, <, audioStart)) {
+                CFRelease(buffer);
+                continue;
+            }
+        }
+
+        if (stopLimit > 0 && CMTIME_IS_VALID(bufferTime)) {
+            CMTime baseline = kCMTimeInvalid;
+            if (CMTIME_IS_VALID(self.firstSampleTime)) {
+                baseline = self.firstSampleTime;
+            } else if (hasAudioStart) {
+                baseline = audioStart;
+            }
+            double frameSeconds = 0.0;
+            if (CMTIME_IS_VALID(baseline)) {
+                frameSeconds = CMTimeGetSeconds(CMTimeSubtract(bufferTime, baseline));
+            }
+            // Adjust camera stop limit by start offset relative to audio
+            double effectiveStopLimit = stopLimit;
+            if (hasAudioStart && CMTIME_IS_VALID(baseline)) {
+                CMTime startDeltaTime = CMTimeSubtract(baseline, audioStart);
+                double startDelta = CMTimeGetSeconds(startDeltaTime);
+                if (startDelta > 0) {
+                    effectiveStopLimit += startDelta;
+                }
+            }
+            double tolerance = self.expectedFrameRate > 0 ? (1.5 / self.expectedFrameRate) : 0.02;
+            if (tolerance < 0.02) {
+                tolerance = 0.02;
+            }
+            if (frameSeconds > effectiveStopLimit + tolerance) {
+                CFRelease(buffer);
+                continue;
+            }
+        }
+
+        [self processSampleBufferReadyForWriting:buffer];
+        CFRelease(buffer);
+    }
+}
+
+- (void)processSampleBufferReadyForWriting:(CMSampleBufferRef)sampleBuffer {
+    if (!sampleBuffer) {
         return;
     }
 
+    CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+
     // Lazy initialization - setup writer with actual frame dimensions
     if (!self.assetWriter) {
         CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
@@ -846,11 +965,9 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         MRLog(@"🎬 First frame received: %zux%zu (format said %dx%d)",
               actualWidth, actualHeight, self.expectedWidth, self.expectedHeight);
 
-        // Use ACTUAL dimensions from the frame, not format dimensions
         NSURL *outputURL = [NSURL fileURLWithPath:self.outputPath];
         NSError *setupError = nil;
 
-        // Use frame rate from device configuration
         double frameRate = self.expectedFrameRate > 0 ? self.expectedFrameRate : 30.0;
 
         if (![self setupWriterWithURL:outputURL
@@ -880,37 +997,58 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
             }
         }
     }
-    
+
     if (!self.writerStarted || self.assetWriter.status != AVAssetWriterStatusWriting) {
         return;
     }
-    
+
     if (!self.assetWriterInput.readyForMoreMediaData) {
         return;
     }
-    
-    CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
-    if (!pixelBuffer) {
-        return;
-    }
-    
+
     if (CMTIME_IS_INVALID(self.firstSampleTime)) {
         self.firstSampleTime = timestamp;
     }
-    
+
     CMTime relativeTimestamp = timestamp;
     if (CMTIME_IS_VALID(self.firstSampleTime)) {
-        // Align camera frames to a zero-based timeline so multi-track compositions stay in sync
         relativeTimestamp = CMTimeSubtract(timestamp, self.firstSampleTime);
         if (CMTIME_COMPARE_INLINE(relativeTimestamp, <, kCMTimeZero)) {
             relativeTimestamp = kCMTimeZero;
         }
     }
-    
+
+    double stopLimit = MRSyncGetStopLimitSeconds();
+    if (stopLimit > 0) {
+        // Adjust by camera start vs audio start so durations align closely
+        CMTime audioStartTS = MRSyncAudioFirstTimestamp();
+        if (CMTIME_IS_VALID(audioStartTS) && CMTIME_IS_VALID(self.firstSampleTime)) {
+            CMTime startDeltaTS = CMTimeSubtract(self.firstSampleTime, audioStartTS);
+            double startDelta = CMTimeGetSeconds(startDeltaTS);
+            if (startDelta > 0) {
+                stopLimit += startDelta;
+            }
+        }
+
+        double frameSeconds = CMTimeGetSeconds(relativeTimestamp);
+        double tolerance = self.expectedFrameRate > 0 ? (1.5 / self.expectedFrameRate) : 0.02;
+        if (tolerance < 0.02) {
+            tolerance = 0.02;
+        }
+        if (frameSeconds > stopLimit + tolerance) {
+            return;
+        }
+    }
+
+    CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+    if (!pixelBuffer) {
+        return;
+    }
+
     CVPixelBufferRetain(pixelBuffer);
     BOOL appended = [self.pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:relativeTimestamp];
     CVPixelBufferRelease(pixelBuffer);
-    
+
     if (!appended) {
         MRLog(@"⚠️ CameraRecorder: Failed to append camera frame at time %.2f (status %ld)",
               CMTimeGetSeconds(relativeTimestamp), (long)self.assetWriter.status);
@@ -921,6 +1059,34 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     }
 }
 
+- (void)captureOutput:(AVCaptureOutput *)output
+ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
+        fromConnection:(AVCaptureConnection *)connection {
+    if (!self.isRecording) {
+        return;
+    }
+
+    if (!sampleBuffer) {
+        return;
+    }
+
+    CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+
+    // If audio is expected but not yet flowing, hold video frames to keep timeline aligned.
+    if (MRSyncShouldHoldVideoFrame(timestamp)) {
+        [self enqueueSampleBuffer:sampleBuffer];
+        if (CMTIME_IS_INVALID(self.firstSampleTime)) {
+            self.firstSampleTime = timestamp;
+        }
+        return;
+    }
+
+    // Flush any buffered frames now that audio is ready
+    [self flushPendingSampleBuffers];
+
+    [self processSampleBufferReadyForWriting:sampleBuffer];
+}
+
 @end
 
 // MARK: - C Interface

package/src/mac_recorder.mm

@@ -383,17 +383,14 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             MRLog(@"   Reason: ScreenCaptureKit has thread safety issues in Electron (SIGTRAP crashes)");
         }
 
-        // CRITICAL FIX: ScreenCaptureKit causes segmentation faults
-        // Forcing AVFoundation for ALL environments until issue is resolved
-        // TODO: Implement audio capture in AVFoundation
+        // CRITICAL FIX: Always use AVFoundation for stability
+        // ScreenCaptureKit has file writing issues in Node.js environment
+        // AVFoundation works reliably in both Node.js and Electron
         BOOL forceAVFoundation = YES;
 
-        MRLog(@"🔧 CRITICAL: ScreenCaptureKit disabled globally (segfault issue)");
-        MRLog(@"   Using AVFoundation for stability with integrated audio capture");
-
-        if (isElectron) {
-            MRLog(@"⚡ Electron environment detected - using stable AVFoundation");
-        }
+        MRLog(@"🔧 FRAMEWORK SELECTION: Using AVFoundation for stability");
+        MRLog(@"   Environment: %@", isElectron ? @"Electron" : @"Node.js");
+        MRLog(@"   macOS: %ld.%ld.%ld", (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
 
         // Electron-first priority: ALWAYS use AVFoundation in Electron for stability
         // ScreenCaptureKit has severe thread safety issues in Electron causing SIGTRAP crashes
@@ -592,6 +589,19 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     MRLog(@"📞 StopRecording native method called");
+
+    double stopLimitSeconds = -1.0;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        stopLimitSeconds = info[0].As<Napi::Number>().DoubleValue();
+        if (stopLimitSeconds > 0) {
+            MRLog(@"⏲️ Requested stop limit: %.3f seconds", stopLimitSeconds);
+            MRSyncSetStopLimitSeconds(stopLimitSeconds);
+        } else {
+            MRSyncSetStopLimitSeconds(-1.0);
+        }
+    } else {
+        MRSyncSetStopLimitSeconds(-1.0);
+    }
     
     // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
@@ -617,6 +627,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
             // DO NOT set g_isRecording here - let ScreenCaptureKit completion handler do it
             // Otherwise we have a race condition where JS thinks recording stopped but it's still running
             g_usingStandaloneAudio = false;
+            MRSyncSetStopLimitSeconds(-1.0);
             return Napi::Boolean::New(env, true);
         }
     }
@@ -631,44 +642,61 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
             MRLog(@"🛑 Stopping AVFoundation recording");
 
             BOOL cameraWasRecording = isCameraRecording();
+            BOOL audioWasRecording = g_usingStandaloneAudio && isStandaloneAudioRecording();
             __block BOOL cameraStopResult = YES;
-            dispatch_group_t cameraStopGroup = NULL;
+            __block BOOL audioStopResult = YES;
+
+            // SYNC FIX: Create unified stop group for camera and audio
+            dispatch_group_t stopGroup = dispatch_group_create();
 
+            // SYNC FIX: Stop camera and audio SIMULTANEOUSLY in parallel
             if (cameraWasRecording) {
-                MRLog(@"🛑 Stopping camera recording...");
+                MRLog(@"🛑 SYNC: Stopping camera recording...");
                 cameraStopResult = NO;
-                cameraStopGroup = dispatch_group_create();
-                dispatch_group_enter(cameraStopGroup);
-                // Stop camera on a background queue so audio/screen shutdown can proceed immediately.
+                dispatch_group_enter(stopGroup);
                 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                     cameraStopResult = stopCameraRecording() ? YES : NO;
-                    dispatch_group_leave(cameraStopGroup);
+                    dispatch_group_leave(stopGroup);
                 });
             }
 
-            // Stop standalone audio if used (ScreenCaptureKit fallback)
-            if (g_usingStandaloneAudio && isStandaloneAudioRecording()) {
-                MRLog(@"🛑 Stopping standalone audio...");
-                stopStandaloneAudioRecording();
+            if (audioWasRecording) {
+                MRLog(@"🛑 SYNC: Stopping audio recording...");
+                audioStopResult = NO;
+                dispatch_group_enter(stopGroup);
+                dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+                    audioStopResult = stopStandaloneAudioRecording() ? YES : NO;
+                    dispatch_group_leave(stopGroup);
+                });
             }
 
             bool avFoundationStopped = stopAVFoundationRecording();
 
-            if (cameraStopGroup) {
-                dispatch_time_t waitTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));
-                long waitResult = dispatch_group_wait(cameraStopGroup, waitTime);
+            // SYNC FIX: Wait for both camera AND audio to finish (increased timeout to 5s)
+            if (cameraWasRecording || audioWasRecording) {
+                dispatch_time_t waitTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC));
+                long waitResult = dispatch_group_wait(stopGroup, waitTime);
                 if (waitResult != 0) {
-                    MRLog(@"⚠️ Camera stop did not finish within 2 seconds (AVFoundation)");
-                    cameraStopResult = NO;
-                } else if (cameraStopResult) {
-                    MRLog(@"✅ Camera stopped successfully");
+                    MRLog(@"⚠️ SYNC: Camera/Audio stop did not finish within 5 seconds");
+                    if (cameraWasRecording && !cameraStopResult) {
+                        MRLog(@"   ⚠️ Camera stop timed out");
+                    }
+                    if (audioWasRecording && !audioStopResult) {
+                        MRLog(@"   ⚠️ Audio stop timed out");
+                    }
                 } else {
-                    MRLog(@"⚠️ Camera stop reported failure");
+                    if (cameraWasRecording) {
+                        MRLog(@"✅ SYNC: Camera stopped successfully");
+                    }
+                    if (audioWasRecording) {
+                        MRLog(@"✅ SYNC: Audio stopped successfully");
+                    }
                 }
             }
 
             g_isRecording = false;
             g_usingStandaloneAudio = false;
+            MRSyncSetStopLimitSeconds(-1.0);
 
             if (avFoundationStopped && (!cameraWasRecording || cameraStopResult)) {
                 MRLog(@"✅ AVFoundation recording stopped");
@@ -690,6 +718,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
         stopCameraRecording();
     }
     g_isRecording = false;
+    MRSyncSetStopLimitSeconds(-1.0);
     return Napi::Boolean::New(env, true);
 }
 

package/src/sync_timeline.h

@@ -20,6 +20,16 @@ BOOL MRSyncShouldHoldVideoFrame(CMTime timestamp);
 // so both tracks share the same starting point.
 void MRSyncMarkAudioSample(CMTime timestamp);
 
+// Returns the offset between audio and video start timestamps when available.
+CMTime MRSyncVideoAlignmentOffset(void);
+
+// Returns the first audio timestamp observed for the current session.
+CMTime MRSyncAudioFirstTimestamp(void);
+
+// Optional hard stop limit (seconds) shared across capture components.
+void MRSyncSetStopLimitSeconds(double seconds);
+double MRSyncGetStopLimitSeconds(void);
+
 #ifdef __cplusplus
 }
 #endif

package/src/sync_timeline.mm

@@ -16,6 +16,7 @@ static CMTime g_videoFirstTimestamp = kCMTimeInvalid;
 static BOOL g_videoHoldLogged = NO;
 static CMTime g_audioFirstTimestamp = kCMTimeInvalid;
 static CMTime g_alignmentDelta = kCMTimeInvalid;
+static double g_stopLimitSeconds = -1.0;
 
 void MRSyncConfigure(BOOL expectAudio) {
     dispatch_sync(MRSyncQueue(), ^{
@@ -25,6 +26,7 @@ void MRSyncConfigure(BOOL expectAudio) {
         g_videoHoldLogged = NO;
         g_audioFirstTimestamp = kCMTimeInvalid;
         g_alignmentDelta = kCMTimeInvalid;
+        g_stopLimitSeconds = -1.0;
     });
 }
 
@@ -71,7 +73,7 @@ BOOL MRSyncShouldHoldVideoFrame(CMTime timestamp) {
         }
 
         CMTime elapsed = CMTimeSubtract(timestamp, g_videoFirstTimestamp);
-        CMTime maxWait = CMTimeMakeWithSeconds(0.25, 600); // Kamera gecikmesini minimumda tut
+        CMTime maxWait = CMTimeMakeWithSeconds(1.0, 600); // SYNC FIX: Increased from 0.25s to 1.0s for better sync tolerance
         if (CMTIME_COMPARE_INLINE(elapsed, >, maxWait)) {
             g_audioReady = YES;
             g_videoFirstTimestamp = kCMTimeInvalid;
@@ -85,9 +87,9 @@ BOOL MRSyncShouldHoldVideoFrame(CMTime timestamp) {
     });
 
     if (logHold) {
-        MRLog(@"⏸️ Video pipeline waiting for audio to begin (holding frames up to 0.35s)");
+        MRLog(@"⏸️ Video pipeline waiting for audio to begin (holding frames up to 1.0s)");
     } else if (logRelease) {
-        MRLog(@"▶️ Video pipeline resume forced (audio not detected within 0.35s)");
+        MRLog(@"▶️ Video pipeline resume forced (audio not detected within 1.0s)");
     }
 
     return shouldHold;
@@ -142,3 +144,17 @@ CMTime MRSyncAudioFirstTimestamp(void) {
     });
     return ts;
 }
+
+void MRSyncSetStopLimitSeconds(double seconds) {
+    dispatch_sync(MRSyncQueue(), ^{
+        g_stopLimitSeconds = seconds;
+    });
+}
+
+double MRSyncGetStopLimitSeconds(void) {
+    __block double seconds = -1.0;
+    dispatch_sync(MRSyncQueue(), ^{
+        seconds = g_stopLimitSeconds;
+    });
+    return seconds;
+}