node-mac-recorder 2.24.6 → 2.24.8

package/binding.gyp

@@ -7,6 +7,7 @@
         "src/screen_capture_kit.mm",
         "src/avfoundation_recorder.mm",
         "src/camera_recorder.mm",
+        "src/ios_device_recorder.mm",
         "src/sync_timeline.mm",
         "src/audio_recorder.mm",
         "src/audio_mixer.mm",
@@ -42,7 +43,8 @@
           "-framework ApplicationServices",
           "-framework Carbon",
           "-framework Accessibility",
-          "-framework CoreAudio"
+          "-framework CoreAudio",
+          "-framework CoreMediaIO"
         ]
       },
       "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]

package/index.js

@@ -153,6 +153,170 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
+	/**
+	 * USB uzerinden AVFoundation muxed capture kaynagi olarak gorunen
+	 * iPhone/iPad cihazlarini listeler. Continuity Camera cihazlari bu listeye
+	 * dahil edilmez; bu kaynak telefonun kamera sensoru degil ekran akışıdır.
+	 */
+	async getIOSCaptureDevices() {
+		if (typeof nativeBinding.getIOSCaptureDevices !== "function") return [];
+		const devices = nativeBinding.getIOSCaptureDevices();
+		if (!Array.isArray(devices)) return [];
+		return devices.map((device) => ({
+			id: device?.id || "",
+			name: device?.name || "iPhone",
+			manufacturer: device?.manufacturer || "Apple",
+			model: device?.model || null,
+			connected: device?.connected !== false,
+			suspended: device?.suspended === true,
+			width: Number(device?.width) || 0,
+			height: Number(device?.height) || 0,
+			hasAudio: device?.hasAudio !== false,
+			transport: device?.transport || "usb",
+		}));
+	}
+
+	/**
+	 * QuickTime benzeri dogrudan USB iPhone ekran kaydi. Muxed aygitin kendi
+	 * video ve sesini tek, uzun-kayitlara dayanikli MOV dosyasina yazar.
+	 */
+	async startIOSRecording(outputPath, options = {}) {
+		if (this.isRecording) throw new Error("Recording is already in progress");
+		if (!outputPath) throw new Error("Output path is required");
+		if (typeof nativeBinding.startIOSDeviceRecording !== "function") {
+			throw new Error("This recorder build does not support USB iPhone capture");
+		}
+
+		const outputDir = path.dirname(outputPath);
+		if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+		this.outputPath = outputPath;
+		const sessionTimestamp = options.sessionTimestamp || Date.now();
+		const cameraOutputPath = options.captureCamera === true
+			? path.join(outputDir, `temp_camera_${sessionTimestamp}.mov`)
+			: null;
+		const audioOutputPath = options.includeMicrophone === true
+			? path.join(outputDir, `temp_audio_${sessionTimestamp}.mov`)
+			: null;
+		this.options = {
+			...this.options,
+			...options,
+			sourceType: "iphone",
+			captureCursor: false,
+			// The muxed USB source already contains the iPhone's own system audio.
+			// includeSystemAudio refers to the Mac and must never be added here.
+			includeSystemAudio: false,
+		};
+		this.cameraCaptureFile = cameraOutputPath;
+		this.audioCaptureFile = audioOutputPath;
+		this.cameraCaptureActive = options.captureCamera === true;
+		this.audioCaptureActive = options.includeMicrophone === true;
+		this.sessionTimestamp = sessionTimestamp;
+		this.recordingMode = "iphone";
+
+		try {
+			const success = nativeBinding.startIOSDeviceRecording(
+				outputPath,
+				options.deviceId || options.iosDeviceId || "",
+				{
+					captureCamera: options.captureCamera === true,
+					cameraOutputPath,
+					cameraDeviceId: options.cameraDeviceId || "",
+					includeMicrophone: options.includeMicrophone === true,
+					audioOutputPath,
+					audioDeviceId: options.audioDeviceId || "",
+				},
+			);
+			if (!success) throw new Error("The iPhone capture session could not be started");
+
+			this.isRecording = true;
+			this.recordingStartTime = Date.now();
+			this.timelineStartTimestamp = this.recordingStartTime;
+			this.syncTimestamp = this.recordingStartTime;
+			this.recordingTimer = setInterval(() => {
+				this.emit(
+					"timeUpdate",
+					Math.floor((Date.now() - this.recordingStartTime) / 1000),
+				);
+			}, 1000);
+
+			const event = {
+				outputPath,
+				timestamp: this.recordingStartTime,
+				options: this.options,
+				nativeConfirmed: true,
+				cursorOutputPath: null,
+				keyboardOutputPath: null,
+				audioOutputPath,
+				cameraOutputPath,
+				sessionTimestamp: this.sessionTimestamp,
+				syncTimestamp: this.syncTimestamp,
+				fileTimestamp: this.sessionTimestamp,
+				sourceType: "iphone",
+			};
+			this.emit("recordingStarted", event);
+			this.emit("started", outputPath);
+			return outputPath;
+		} catch (error) {
+			this.recordingMode = null;
+			this.isRecording = false;
+			this.cameraCaptureActive = false;
+			this.audioCaptureActive = false;
+			this.cameraCaptureFile = null;
+			this.audioCaptureFile = null;
+			throw error;
+		}
+	}
+
+	async stopIOSRecording() {
+		if (this.recordingMode !== "iphone" || !this.isRecording) {
+			throw new Error("No iPhone recording in progress");
+		}
+		let success = false;
+		try {
+			success = nativeBinding.stopIOSDeviceRecording();
+		} finally {
+			if (this.recordingTimer) clearInterval(this.recordingTimer);
+			this.recordingTimer = null;
+			this.isRecording = false;
+			this.recordingMode = null;
+		}
+
+		const result = {
+			code: success ? 0 : 1,
+			outputPath: this.outputPath,
+			cameraOutputPath: this.cameraCaptureFile || null,
+			audioOutputPath: this.audioCaptureFile || null,
+			sessionTimestamp: this.sessionTimestamp,
+			syncTimestamp: this.syncTimestamp,
+			sourceType: "iphone",
+		};
+		if (this.cameraCaptureActive) {
+			this.emit("cameraCaptureStopped", {
+				outputPath: this.cameraCaptureFile,
+				success,
+				sessionTimestamp: this.sessionTimestamp,
+				syncTimestamp: this.syncTimestamp,
+			});
+		}
+		if (this.audioCaptureActive) {
+			this.emit("audioCaptureStopped", {
+				outputPath: this.audioCaptureFile,
+				success,
+				sessionTimestamp: this.sessionTimestamp,
+				syncTimestamp: this.syncTimestamp,
+			});
+		}
+		this.cameraCaptureActive = false;
+		this.audioCaptureActive = false;
+		this.emit("stopped", result);
+		if (success && fs.existsSync(this.outputPath)) {
+			this.emit("completed", this.outputPath);
+		}
+		this.sessionTimestamp = null;
+		this.syncTimestamp = null;
+		return result;
+	}
+
 	/**
 	 * macOS ekranlarını listeler
 	 */
@@ -1227,6 +1391,9 @@ class MacRecorder extends EventEmitter {
 		if (!this.isRecording) {
 			throw new Error("No recording in progress");
 		}
+		if (this.recordingMode === "iphone") {
+			return this.stopIOSRecording();
+		}
 
 		return new Promise(async (resolve, reject) => {
 			const stopRequestedAt = Date.now();
@@ -1399,7 +1566,11 @@ class MacRecorder extends EventEmitter {
 	 * Kayıt durumunu döndürür
 	 */
 	getStatus() {
-		const nativeStatus = nativeBinding.getRecordingStatus();
+		const nativeStatus =
+			this.recordingMode === "iphone" &&
+			typeof nativeBinding.getIOSDeviceRecordingStatus === "function"
+				? nativeBinding.getIOSDeviceRecordingStatus().isRecording === true
+				: nativeBinding.getRecordingStatus();
 		return {
 			isRecording: this.isRecording && nativeStatus,
 			outputPath: this.outputPath,
@@ -1416,6 +1587,31 @@ class MacRecorder extends EventEmitter {
 		};
 	}
 
+	/**
+	 * Pencere kaydında hedef pencerenin uygulamasını aktive eder.
+	 *
+	 * Kayıt başlarken kaydedilen uygulama pasif kalırsa, odağını kaybedince
+	 * gizlenen pencereler (iTerm2 hotkey window vb.) kendini gizler ve kayıtta
+	 * görünmez. Kayıt komutu verildiğinde odak bizde olduğu için bu adım şart.
+	 *
+	 * @param {number} windowId CGWindowID
+	 * @returns {boolean}
+	 */
+	activateWindowOwnerApp(windowId) {
+		const id = Number(windowId);
+		if (!Number.isFinite(id) || id <= 0) return false;
+		if (typeof nativeBinding.activateWindowOwnerApp !== "function") return false;
+		try {
+			return !!nativeBinding.activateWindowOwnerApp(id);
+		} catch (error) {
+			console.warn(
+				"[MacRecorder] activateWindowOwnerApp başarısız:",
+				error?.message || error,
+			);
+			return false;
+		}
+	}
+
 	/**
 	 * Encoder'ın gerçek zamanlı yetişip yetişmediğini gösteren kare sayaçları.
 	 * Kayıt sırasında canlı, bittikten sonra son oturumun değerlerini döndürür.

package/package.json

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

package/src/audio_recorder.mm

@@ -337,6 +337,12 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
     
     CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
 
+    // Keep microphone warm-up outside the recording until the USB iPhone movie
+    // output has actually started writing its first frame.
+    if (MRSyncShouldHoldForPrimary(timestamp)) {
+        return;
+    }
+
     // A/V SYNC: Hold audio samples until camera produces first frame
     // This ensures both audio and camera files start from the same wall-clock moment
     if (MRSyncShouldHoldAudioSample(timestamp)) {

package/src/camera_recorder.mm

@@ -526,6 +526,12 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
 
     CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
 
+    // Drop camera warm-up frames until the primary source (USB iPhone screen)
+    // has committed its first frame. This keeps all files on one t=0 boundary.
+    if (MRSyncShouldHoldForPrimary(timestamp)) {
+        return;
+    }
+
     // A/V SYNC: Signal camera's first frame to release audio hold
     MRSyncMarkCameraFirstFrame(timestamp);
 

package/src/ios_device_recorder.mm

@@ -0,0 +1,534 @@
+#import <napi.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMediaIO/CMIOHardware.h>
+#import <Foundation/Foundation.h>
+#import "logging.h"
+#import "sync_timeline.h"
+
+extern "C" bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
+extern "C" bool waitForCameraRecordingStart(double timeoutSeconds);
+extern "C" bool stopCameraRecording(void);
+extern "C" bool isCameraRecording(void);
+extern "C" bool startStandaloneAudioRecording(NSString *outputPath, NSString *preferredDeviceId, NSError **error);
+extern "C" bool stopStandaloneAudioRecording(void);
+extern "C" bool isStandaloneAudioRecording(void);
+
+@interface MRIOSDeviceRecorder : NSObject <AVCaptureFileOutputRecordingDelegate>
+@property(nonatomic, strong) AVCaptureSession *session;
+@property(nonatomic, strong) AVCaptureDeviceInput *deviceInput;
+@property(nonatomic, strong) AVCaptureMovieFileOutput *movieOutput;
+@property(nonatomic, copy) NSString *outputPath;
+@property(atomic) BOOL recording;
+@property(atomic) BOOL startCompleted;
+@property(atomic) BOOL finishCompleted;
+@property(atomic, strong) NSError *finishError;
+@property(nonatomic) BOOL captureCamera;
+@property(nonatomic) BOOL captureMicrophone;
+@property(nonatomic, copy) NSString *cameraOutputPath;
+@property(nonatomic, copy) NSString *audioOutputPath;
+@property(nonatomic, strong) NSDate *primaryStartedAt;
+@end
+
+@implementation MRIOSDeviceRecorder
+
+- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
+        didStartRecordingToOutputFileAtURL:(NSURL *)fileURL
+        fromConnections:(NSArray<AVCaptureConnection *> *)connections {
+    self.recording = YES;
+    self.startCompleted = YES;
+    self.primaryStartedAt = [NSDate date];
+    MRSyncMarkPrimaryStarted(CMClockGetTime(CMClockGetHostTimeClock()));
+    MRLog(@"📱 iPhone capture started: %@", fileURL.path);
+}
+
+- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
+        didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL
+        fromConnections:(NSArray<AVCaptureConnection *> *)connections
+        error:(NSError *)error {
+    self.recording = NO;
+    self.finishError = error;
+    self.finishCompleted = YES;
+    if (error) {
+        NSNumber *successfullyFinished = error.userInfo[AVErrorRecordingSuccessfullyFinishedKey];
+        if (![successfullyFinished boolValue]) {
+            MRLog(@"❌ iPhone capture finalize failed: %@", error.localizedDescription);
+            return;
+        }
+    }
+    MRLog(@"✅ iPhone capture finalized: %@", outputFileURL.path);
+}
+
+@end
+
+static MRIOSDeviceRecorder *g_iosRecorder = nil;
+
+static void MREnableIOSScreenCaptureDevices(void) {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        CMIOObjectPropertyAddress address = {
+            kCMIOHardwarePropertyAllowScreenCaptureDevices,
+            kCMIOObjectPropertyScopeGlobal,
+            kCMIOObjectPropertyElementMain
+        };
+        UInt32 allow = 1;
+        OSStatus status = CMIOObjectSetPropertyData(
+            kCMIOObjectSystemObject,
+            &address,
+            0,
+            NULL,
+            sizeof(allow),
+            &allow
+        );
+        if (status == noErr) {
+            MRLog(@"✅ CoreMediaIO iPhone screen capture devices enabled");
+        } else {
+            MRLog(@"❌ CoreMediaIO could not enable iPhone screen capture devices (OSStatus=%d)", (int)status);
+        }
+    });
+}
+
+static NSArray<AVCaptureDevice *> *MRDiscoverIOSCaptureDevices(void) {
+    NSMutableArray<AVCaptureDevice *> *result = [NSMutableArray array];
+    NSMutableSet<NSString *> *seenIds = [NSMutableSet set];
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    for (AVCaptureDevice *device in [AVCaptureDevice devicesWithMediaType:AVMediaTypeMuxed]) {
+        if (device.uniqueID.length == 0 || [seenIds containsObject:device.uniqueID]) continue;
+        [seenIds addObject:device.uniqueID];
+        [result addObject:device];
+    }
+#pragma clang diagnostic pop
+
+    NSMutableArray<AVCaptureDeviceType> *deviceTypes = [NSMutableArray array];
+    if (@available(macOS 10.15, *)) {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternalUnknown];
+    }
+    if (@available(macOS 14.0, *)) {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternal];
+    }
+    if (deviceTypes.count > 0) {
+        AVCaptureDeviceDiscoverySession *discovery =
+            [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:deviceTypes
+                                                                   mediaType:AVMediaTypeMuxed
+                                                                    position:AVCaptureDevicePositionUnspecified];
+        for (AVCaptureDevice *device in discovery.devices) {
+            if (device.uniqueID.length == 0 || [seenIds containsObject:device.uniqueID]) continue;
+            [seenIds addObject:device.uniqueID];
+            [result addObject:device];
+        }
+    }
+    return result;
+}
+
+static NSArray<AVCaptureDevice *> *MRIOSCaptureDevices(void) {
+    MREnableIOSScreenCaptureDevices();
+
+    // CoreMediaIO publishes the USB screen device asynchronously after the
+    // allow flag changes. Poll briefly so the first click works without asking
+    // the user to close and reopen the recorder.
+    NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:3.0];
+    NSArray<AVCaptureDevice *> *devices = nil;
+    do {
+        devices = MRDiscoverIOSCaptureDevices();
+        if (devices.count > 0) break;
+        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
+                                 beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.05]];
+    } while ([deadline timeIntervalSinceNow] > 0);
+    return devices ?: @[];
+}
+
+static AVCaptureDevice *MRIOSDeviceForId(NSString *deviceId) {
+    NSArray<AVCaptureDevice *> *devices = MRIOSCaptureDevices();
+    if (deviceId.length == 0) return devices.firstObject;
+    for (AVCaptureDevice *device in devices) {
+        if ([device.uniqueID isEqualToString:deviceId]) return device;
+    }
+    return nil;
+}
+
+static bool MRWaitForFlag(bool (^readFlag)(void), NSTimeInterval timeoutSeconds) {
+    NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:timeoutSeconds];
+    while (!readFlag() && [deadline timeIntervalSinceNow] > 0) {
+        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
+                                 beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+    }
+    return readFlag();
+}
+
+extern "C" NSArray<NSDictionary *> *listIOSCaptureDevices(void) {
+    NSMutableArray<NSDictionary *> *devices = [NSMutableArray array];
+    for (AVCaptureDevice *device in MRIOSCaptureDevices()) {
+        CMVideoDimensions largest = {0, 0};
+        for (AVCaptureDeviceFormat *format in device.formats) {
+            CMVideoDimensions dimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
+            if ((int64_t)dimensions.width * dimensions.height >
+                (int64_t)largest.width * largest.height) {
+                largest = dimensions;
+            }
+        }
+        [devices addObject:@{
+            @"id": device.uniqueID ?: @"",
+            @"name": device.localizedName ?: @"iPhone",
+            @"manufacturer": device.manufacturer ?: @"Apple",
+            @"model": device.modelID ?: @"",
+            @"connected": @(device.isConnected),
+            @"suspended": @(device.isSuspended),
+            @"width": @(largest.width),
+            @"height": @(largest.height),
+            @"hasAudio": @YES,
+            @"transport": @"usb"
+        }];
+    }
+    return devices;
+}
+
+extern "C" bool startIOSDeviceRecording(NSString *outputPath,
+                                         NSString *deviceId,
+                                         BOOL captureCamera,
+                                         NSString *cameraOutputPath,
+                                         NSString *cameraDeviceId,
+                                         BOOL captureMicrophone,
+                                         NSString *audioOutputPath,
+                                         NSString *audioDeviceId,
+                                         NSError **errorOut) {
+    @autoreleasepool {
+        if (g_iosRecorder && (g_iosRecorder.recording || g_iosRecorder.startCompleted)) {
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:1
+                                            userInfo:@{NSLocalizedDescriptionKey: @"An iPhone recording is already active"}];
+            }
+            return false;
+        }
+
+        AVCaptureDevice *device = MRIOSDeviceForId(deviceId);
+        if (!device) {
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:2
+                                            userInfo:@{NSLocalizedDescriptionKey: @"No trusted USB iPhone capture device was found"}];
+            }
+            return false;
+        }
+
+        NSError *directoryError = nil;
+        NSString *directory = [outputPath stringByDeletingLastPathComponent];
+        [[NSFileManager defaultManager] createDirectoryAtPath:directory
+                                  withIntermediateDirectories:YES
+                                                   attributes:nil
+                                                        error:&directoryError];
+        if (directoryError) {
+            if (errorOut) *errorOut = directoryError;
+            return false;
+        }
+        [[NSFileManager defaultManager] removeItemAtPath:outputPath error:nil];
+        if (captureCamera && cameraOutputPath.length > 0) {
+            [[NSFileManager defaultManager] removeItemAtPath:cameraOutputPath error:nil];
+        }
+        if (captureMicrophone && audioOutputPath.length > 0) {
+            [[NSFileManager defaultManager] removeItemAtPath:audioOutputPath error:nil];
+        }
+
+        NSError *inputError = nil;
+        AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device
+                                                                            error:&inputError];
+        if (!input) {
+            if (errorOut) *errorOut = inputError;
+            return false;
+        }
+
+        MRIOSDeviceRecorder *recorder = [[MRIOSDeviceRecorder alloc] init];
+        recorder.session = [[AVCaptureSession alloc] init];
+        recorder.deviceInput = input;
+        recorder.movieOutput = [[AVCaptureMovieFileOutput alloc] init];
+        recorder.outputPath = outputPath;
+        recorder.recording = NO;
+        recorder.startCompleted = NO;
+        recorder.finishCompleted = NO;
+        recorder.finishError = nil;
+        recorder.captureCamera = captureCamera;
+        recorder.captureMicrophone = captureMicrophone;
+        recorder.cameraOutputPath = cameraOutputPath;
+        recorder.audioOutputPath = audioOutputPath;
+        recorder.primaryStartedAt = nil;
+
+        [recorder.session beginConfiguration];
+        if ([recorder.session canSetSessionPreset:AVCaptureSessionPresetHigh]) {
+            recorder.session.sessionPreset = AVCaptureSessionPresetHigh;
+        }
+        if (![recorder.session canAddInput:input]) {
+            [recorder.session commitConfiguration];
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:3
+                                            userInfo:@{NSLocalizedDescriptionKey: @"The iPhone capture input could not be attached"}];
+            }
+            return false;
+        }
+        [recorder.session addInput:input];
+        if (![recorder.session canAddOutput:recorder.movieOutput]) {
+            [recorder.session commitConfiguration];
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:4
+                                            userInfo:@{NSLocalizedDescriptionKey: @"The iPhone movie output could not be attached"}];
+            }
+            return false;
+        }
+        [recorder.session addOutput:recorder.movieOutput];
+        [recorder.session commitConfiguration];
+
+        // Frequent movie fragments keep long recordings recoverable if the cable
+        // disconnects or the app exits before the final movie atom is written.
+        recorder.movieOutput.movieFragmentInterval = CMTimeMakeWithSeconds(2.0, 600);
+        g_iosRecorder = recorder;
+
+        // Camera and microphone sessions are prepared first but discard their
+        // warm-up samples until AVCaptureMovieFileOutput confirms the iPhone's
+        // first frame. Every produced file therefore starts at the same t=0.
+        MRSyncConfigure(captureMicrophone);
+        MRSyncConfigureCamera(captureCamera);
+        MRSyncConfigurePrimaryStart(captureCamera || captureMicrophone);
+
+        if (captureCamera) {
+            NSError *cameraError = nil;
+            if (cameraOutputPath.length == 0 ||
+                !startCameraRecording(cameraOutputPath, cameraDeviceId, &cameraError)) {
+                MRSyncConfigurePrimaryStart(NO);
+                MRSyncConfigure(NO);
+                g_iosRecorder = nil;
+                if (errorOut) {
+                    *errorOut = cameraError ?: [NSError errorWithDomain:@"MacRecorderIOS"
+                                                                    code:7
+                                                                userInfo:@{NSLocalizedDescriptionKey: @"The selected camera could not be started"}];
+                }
+                return false;
+            }
+        }
+
+        if (captureMicrophone) {
+            NSError *audioError = nil;
+            if (audioOutputPath.length == 0 ||
+                !startStandaloneAudioRecording(audioOutputPath, audioDeviceId, &audioError)) {
+                if (isCameraRecording()) stopCameraRecording();
+                MRSyncConfigurePrimaryStart(NO);
+                MRSyncConfigure(NO);
+                g_iosRecorder = nil;
+                if (errorOut) {
+                    *errorOut = audioError ?: [NSError errorWithDomain:@"MacRecorderIOS"
+                                                                  code:8
+                                                              userInfo:@{NSLocalizedDescriptionKey: @"The selected microphone could not be started"}];
+                }
+                return false;
+            }
+        }
+
+        [recorder.session startRunning];
+        if (!recorder.session.isRunning) {
+            if (isCameraRecording()) stopCameraRecording();
+            if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
+            MRSyncConfigurePrimaryStart(NO);
+            MRSyncConfigure(NO);
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:5
+                                            userInfo:@{NSLocalizedDescriptionKey: @"The iPhone capture session did not start"}];
+            }
+            g_iosRecorder = nil;
+            return false;
+        }
+
+        [recorder.movieOutput startRecordingToOutputFileURL:[NSURL fileURLWithPath:outputPath]
+                                          recordingDelegate:recorder];
+        bool started = MRWaitForFlag(^bool{
+            return recorder.startCompleted;
+        }, 10.0);
+        if (!started) {
+            if (recorder.movieOutput.isRecording) [recorder.movieOutput stopRecording];
+            [recorder.session stopRunning];
+            if (isCameraRecording()) stopCameraRecording();
+            if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
+            MRSyncConfigurePrimaryStart(NO);
+            MRSyncConfigure(NO);
+            g_iosRecorder = nil;
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:6
+                                            userInfo:@{NSLocalizedDescriptionKey: @"Timed out waiting for the first iPhone frame"}];
+            }
+            return false;
+        }
+        if (captureCamera && !waitForCameraRecordingStart(8.0)) {
+            MRLog(@"❌ Camera did not produce a synchronized frame for iPhone recording");
+            if (recorder.movieOutput.isRecording) [recorder.movieOutput stopRecording];
+            MRWaitForFlag(^bool{ return recorder.finishCompleted; }, 10.0);
+            [recorder.session stopRunning];
+            if (isCameraRecording()) stopCameraRecording();
+            if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
+            MRSyncConfigurePrimaryStart(NO);
+            MRSyncConfigure(NO);
+            g_iosRecorder = nil;
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:9
+                                            userInfo:@{NSLocalizedDescriptionKey: @"Timed out waiting for the selected camera"}];
+            }
+            return false;
+        }
+        return true;
+    }
+}
+
+extern "C" bool stopIOSDeviceRecording(void) {
+    @autoreleasepool {
+        MRIOSDeviceRecorder *recorder = g_iosRecorder;
+        if (!recorder) return true;
+
+        if (recorder.primaryStartedAt) {
+            NSTimeInterval duration = MAX(0.0, -[recorder.primaryStartedAt timeIntervalSinceNow]);
+            MRSyncSetStopLimitSeconds(duration);
+        }
+
+        BOOL cameraStopped = YES;
+        BOOL microphoneStopped = YES;
+        if (recorder.captureCamera && isCameraRecording()) {
+            cameraStopped = stopCameraRecording();
+        }
+        if (recorder.captureMicrophone && isStandaloneAudioRecording()) {
+            microphoneStopped = stopStandaloneAudioRecording();
+        }
+
+        if (recorder.movieOutput.isRecording) {
+            [recorder.movieOutput stopRecording];
+            MRWaitForFlag(^bool{
+                return recorder.finishCompleted;
+            }, 20.0);
+        }
+        if (recorder.session.isRunning) [recorder.session stopRunning];
+
+        NSError *finishError = recorder.finishError;
+        BOOL finished = recorder.finishCompleted || !recorder.startCompleted;
+        BOOL fileExists = [[NSFileManager defaultManager] fileExistsAtPath:recorder.outputPath];
+        MRSyncConfigurePrimaryStart(NO);
+        MRSyncConfigure(NO);
+        g_iosRecorder = nil;
+
+        if (finishError) {
+            NSNumber *successfullyFinished = finishError.userInfo[AVErrorRecordingSuccessfullyFinishedKey];
+            if (![successfullyFinished boolValue]) return false;
+        }
+        if (!cameraStopped || !microphoneStopped) {
+            MRLog(@"⚠️ iPhone recording finalized, but an auxiliary camera/microphone writer reported a stop error");
+        }
+        // Never discard a valid phone screen recording because an optional
+        // auxiliary source failed to finalize. The JS layer validates each
+        // returned path independently before packaging it.
+        return finished && fileExists;
+    }
+}
+
+extern "C" bool isIOSDeviceRecording(void) {
+    return g_iosRecorder && (g_iosRecorder.recording || g_iosRecorder.movieOutput.isRecording);
+}
+
+extern "C" NSString *currentIOSDeviceRecordingPath(void) {
+    return g_iosRecorder.outputPath;
+}
+
+Napi::Value GetIOSCaptureDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    NSArray<NSDictionary *> *devices = listIOSCaptureDevices();
+    Napi::Array result = Napi::Array::New(env, devices.count);
+    for (NSUInteger index = 0; index < devices.count; index++) {
+        NSDictionary *device = devices[index];
+        Napi::Object item = Napi::Object::New(env);
+        item.Set("id", Napi::String::New(env, [device[@"id"] UTF8String]));
+        item.Set("name", Napi::String::New(env, [device[@"name"] UTF8String]));
+        item.Set("manufacturer", Napi::String::New(env, [device[@"manufacturer"] UTF8String]));
+        item.Set("model", Napi::String::New(env, [device[@"model"] UTF8String]));
+        item.Set("connected", Napi::Boolean::New(env, [device[@"connected"] boolValue]));
+        item.Set("suspended", Napi::Boolean::New(env, [device[@"suspended"] boolValue]));
+        item.Set("width", Napi::Number::New(env, [device[@"width"] intValue]));
+        item.Set("height", Napi::Number::New(env, [device[@"height"] intValue]));
+        item.Set("hasAudio", Napi::Boolean::New(env, true));
+        item.Set("transport", Napi::String::New(env, "usb"));
+        result.Set(index, item);
+    }
+    return result;
+}
+
+Napi::Value StartIOSDeviceRecording(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Output path is required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    NSString *outputPath = [NSString stringWithUTF8String:info[0].As<Napi::String>().Utf8Value().c_str()];
+    NSString *deviceId = nil;
+    if (info.Length() > 1 && info[1].IsString()) {
+        deviceId = [NSString stringWithUTF8String:info[1].As<Napi::String>().Utf8Value().c_str()];
+    }
+    BOOL captureCamera = NO;
+    BOOL captureMicrophone = NO;
+    NSString *cameraOutputPath = nil;
+    NSString *cameraDeviceId = nil;
+    NSString *audioOutputPath = nil;
+    NSString *audioDeviceId = nil;
+    if (info.Length() > 2 && info[2].IsObject()) {
+        Napi::Object options = info[2].As<Napi::Object>();
+        auto readBool = [&](const char *key) -> BOOL {
+            Napi::Value value = options.Get(key);
+            return value.IsBoolean() && value.As<Napi::Boolean>().Value();
+        };
+        auto readString = [&](const char *key) -> NSString * {
+            Napi::Value value = options.Get(key);
+            if (!value.IsString()) return nil;
+            std::string text = value.As<Napi::String>().Utf8Value();
+            return text.empty() ? nil : [NSString stringWithUTF8String:text.c_str()];
+        };
+        captureCamera = readBool("captureCamera");
+        captureMicrophone = readBool("includeMicrophone");
+        cameraOutputPath = readString("cameraOutputPath");
+        cameraDeviceId = readString("cameraDeviceId");
+        audioOutputPath = readString("audioOutputPath");
+        audioDeviceId = readString("audioDeviceId");
+    }
+    NSError *error = nil;
+    bool success = startIOSDeviceRecording(outputPath,
+                                           deviceId,
+                                           captureCamera,
+                                           cameraOutputPath,
+                                           cameraDeviceId,
+                                           captureMicrophone,
+                                           audioOutputPath,
+                                           audioDeviceId,
+                                           &error);
+    if (!success && error) {
+        // startIOSDeviceRecording owns an inner autorelease pool. Do not bridge
+        // the NSError past that pool into V8; the JS wrapper turns false into a
+        // stable user-facing error and avoids a dangling Objective-C object.
+        MRLog(@"❌ iPhone capture could not start");
+    }
+    return Napi::Boolean::New(env, success);
+}
+
+Napi::Value StopIOSDeviceRecording(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), stopIOSDeviceRecording());
+}
+
+Napi::Value GetIOSDeviceRecordingStatus(const Napi::CallbackInfo& info) {
+    Napi::Object status = Napi::Object::New(info.Env());
+    status.Set("isRecording", Napi::Boolean::New(info.Env(), isIOSDeviceRecording()));
+    NSString *path = currentIOSDeviceRecordingPath();
+    if (path.length > 0) status.Set("outputPath", Napi::String::New(info.Env(), [path UTF8String]));
+    return status;
+}
+
+Napi::Object InitIOSDeviceRecorder(Napi::Env env, Napi::Object exports) {
+    exports.Set("getIOSCaptureDevices", Napi::Function::New(env, GetIOSCaptureDevices));
+    exports.Set("startIOSDeviceRecording", Napi::Function::New(env, StartIOSDeviceRecording));
+    exports.Set("stopIOSDeviceRecording", Napi::Function::New(env, StopIOSDeviceRecording));
+    exports.Set("getIOSDeviceRecordingStatus", Napi::Function::New(env, GetIOSDeviceRecordingStatus));
+    return exports;
+}

package/src/mac_recorder.mm

@@ -55,6 +55,9 @@ Napi::Object InitKeyboardTracker(Napi::Env env, Napi::Object exports);
 // Window selector function declarations
 Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports);
 
+// USB iPhone/iPad screen capture functions
+Napi::Object InitIOSDeviceRecorder(Napi::Env env, Napi::Object exports);
+
 // Window selector overlay functions (external)
 extern "C" void hideOverlays();
 extern "C" void showOverlays();
@@ -1779,6 +1782,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
 
     // Initialize window selector
     InitWindowSelector(env, exports);
+
+    // Initialize direct USB iPhone/iPad capture
+    InitIOSDeviceRecorder(env, exports);
     
     return exports;
 }

package/src/screen_capture_kit.mm

@@ -1600,6 +1600,7 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
 
                 // Find display containing this window to get scale factor
                 CGFloat scaleFactor = 1.0;
+                SCDisplay *windowDisplay = nil;
                 CGPoint windowCenter = CGPointMake(
                     targetWindow.frame.origin.x + windowLogicalWidth / 2.0,
                     targetWindow.frame.origin.y + windowLogicalHeight / 2.0
@@ -1608,6 +1609,7 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
                     CGRect dispBounds = CGRectMake(disp.frame.origin.x, disp.frame.origin.y,
                                                    disp.frame.size.width, disp.frame.size.height);
                     if (CGRectContainsPoint(dispBounds, windowCenter)) {
+                        windowDisplay = disp;
                         scaleFactor = SCKBackingScaleForDisplay(disp);
                         break;
                     }
@@ -1615,24 +1617,32 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
                 // Fallback: use main display scale factor
                 if (scaleFactor == 1.0 && content.displays.count > 0) {
                     SCDisplay *mainDisp = content.displays.firstObject;
+                    if (!windowDisplay) windowDisplay = mainDisp;
                     scaleFactor = SCKBackingScaleForDisplay(mainDisp);
                 }
 
+                // DOGRUDAN pencere yakalama. Ekrandan kirpma/kompozit YOK: bu
+                // filtre pencereyi kendi basina yakalar, pencere tasinsa da takip
+                // eder. (Display kompozit alternatifi denendi ve reddedildi.)
                 filter = [[SCContentFilter alloc] initWithDesktopIndependentWindow:targetWindow];
+
+                CGFloat displayScale = scaleFactor;
+                CGFloat filterScaleLog = -1.0;
                 if (@available(macOS 14.0, *)) {
-                    // ScreenCaptureKit exposes the authoritative point→pixel
-                    // conversion for this exact filter. Prefer it over display
-                    // heuristics (scaled modes and windows spanning displays).
+                    // filter.pointPixelScale, SCK'nin bu filtre icin GERCEKTEN
+                    // uretecegi point->pixel oranidir; tek yetkili kaynak odur.
+                    //
+                    // Eskiden MAX(displayScale, filterScale) aliniyordu. Bu yanlis:
+                    // olculdu ki harici 3440x1440 (1x) ekranda display heuristigi
+                    // 2.00 donerken filtre dogru sekilde 1.00 donuyor. MAX ile 2x
+                    // istenince SCK yine 1x uretiyor ve icerik karenin sol ust
+                    // ceyregine sikisip geri kalani siyah kaliyordu.
+                    // Retina'da filtre zaten 2.00 donuyor (olculdu), yani Retina
+                    // keskinligi kaybi YOK.
                     CGFloat filterScale = filter.pointPixelScale;
+                    filterScaleLog = filterScale;
                     if (isfinite(filterScale) && filterScale >= 1.0 && filterScale <= 4.0) {
-                        // desktopIndependentWindow filtresi bazı macOS/sürüm
-                        // kombinasyonlarında Retina pencerede bile 1.0 dönebiliyor.
-                        // Display geometrisinden bulunan 2x değeri 1x'e indirirsek
-                        // 1500x960 pencere gerçek 3000x1920 yerine logical boyutta
-                        // kaydediliyor ve zoom'da metin detayı geri dönülemez
-                        // biçimde kayboluyor. Filter yalnızca daha yüksek/güvenli
-                        // bir backing scale bildiriyorsa heuristiği yükseltsin.
-                        scaleFactor = MAX(scaleFactor, filterScale);
+                        scaleFactor = filterScale;
                     }
                 }
                 scaleFactor = MIN(4.0, MAX(1.0, scaleFactor));
@@ -1640,9 +1650,11 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
                 NSInteger physicalWindowWidth = (NSInteger)llround(windowLogicalWidth * scaleFactor);
                 NSInteger physicalWindowHeight = (NSInteger)llround(windowLogicalHeight * scaleFactor);
 
-                MRLog(@"🪟 Recording window: %@ logical=%ux%u, physical=%ldx%ld, scale=%.2fx",
+                MRLog(@"🪟 Recording window: %@ logical=%ux%u, physical=%ldx%ld, scale=%.2fx "
+                      @"(displayScale=%.2f filterScale=%.2f)",
                       targetWindow.title, (unsigned)windowLogicalWidth, (unsigned)windowLogicalHeight,
-                      (long)physicalWindowWidth, (long)physicalWindowHeight, scaleFactor);
+                      (long)physicalWindowWidth, (long)physicalWindowHeight, scaleFactor,
+                      displayScale, filterScaleLog);
                 recordingWidth = physicalWindowWidth;
                 recordingHeight = physicalWindowHeight;
             } else {
@@ -1696,8 +1708,12 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
                         logicalWidth = filterRect.size.width;
                         logicalHeight = filterRect.size.height;
                     }
+                    // Pencere dalindaki ile ayni kural: SCK'nin uretecegi olcek
+                    // filtreden okunur. MAX(display, filter) yanlisti — harici
+                    // 3440x1440 (1x) ekranda display heuristigi 2.00 donuyor ve
+                    // istenen boyut SCK'nin urettiginin iki kati oluyordu.
                     if (isfinite(filterScale) && filterScale >= 1.0 && filterScale <= 4.0) {
-                        scaleFactor = MAX(scaleFactor, filterScale);
+                        scaleFactor = filterScale;
                     }
                 }
                 scaleFactor = MIN(4.0, MAX(1.0, scaleFactor));
@@ -1732,9 +1748,10 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
                 if (targetDisplay) {
                     cropScaleFactor = SCKBackingScaleForDisplay(targetDisplay);
                     if (@available(macOS 14.0, *)) {
+                        // Ekran/pencere dallariyla ayni kural: yetkili kaynak filtre.
                         CGFloat filterScale = filter.pointPixelScale;
                         if (isfinite(filterScale) && filterScale >= 1.0 && filterScale <= 4.0) {
-                            cropScaleFactor = MAX(cropScaleFactor, filterScale);
+                            cropScaleFactor = filterScale;
                         }
                     }
                 }
@@ -1779,11 +1796,19 @@ static void SCKPerformRecordingSetup(NSDictionary *config, SCShareableContent *c
             streamConfig.queueDepth = 8;
         }
         if (@available(macOS 14.0, *)) {
-            // Use best capture resolution for maximum quality on Retina displays
-            streamConfig.captureResolution = SCCaptureResolutionBest;
-            // Make stream opaque to avoid alpha channel overhead
+            // captureResolution = SCCaptureResolutionBest BILEREK KULLANILMIYOR.
+            //
+            // Retina kalitesi icin eklenmisti ama GPU (Metal) ile cizen
+            // uygulamalarda pencere kaydinda ICERIGI TAMAMEN DUSURUYOR: iTerm2'de
+            // sekme cubugu/bolme basliklari (AppKit) geliyor, oturum icerigi
+            // (Metal katmani) simsiyah cikiyordu. Olculdu: ayni pencere, ayni
+            // kosullar, sadece bu satir kapaliyken icerik geri geldi.
+            // Cozunurluk zaten streamConfig.width/height ile isteniyor; bu ayara
+            // ihtiyac yok.
+            //
+            // shouldBeOpaque ve colorSpaceName ayni deneyde TEST EDILDI ve
+            // masum cikti (ikisi de acikken icerik geliyor) - dokunulmadi.
             streamConfig.shouldBeOpaque = YES;
-            MRLog(@"🎯 Using SCCaptureResolutionBest + shouldBeOpaque for maximum quality (macOS 14+)");
         }
         if (@available(macOS 13.0, *)) {
             // Frame'leri bilinen bir renk uzayında (sRGB) iste; encoder tarafında

package/src/sync_timeline.h

@@ -32,6 +32,14 @@ void MRSyncConfigureCamera(BOOL expectCamera);
 void MRSyncMarkCameraFirstFrame(CMTime timestamp);
 BOOL MRSyncShouldHoldAudioSample(CMTime timestamp);
 
+// Some primary sources (for example a USB iPhone muxed device) need a short
+// asynchronous warm-up before their first frame is committed. Camera and
+// microphone writers can use this barrier to discard their warm-up samples and
+// begin at the same host-clock instant as that primary source.
+void MRSyncConfigurePrimaryStart(BOOL expectPrimary);
+void MRSyncMarkPrimaryStarted(CMTime timestamp);
+BOOL MRSyncShouldHoldForPrimary(CMTime timestamp);
+
 // Optional hard stop limit (seconds) shared across capture components.
 void MRSyncSetStopLimitSeconds(double seconds);
 double MRSyncGetStopLimitSeconds(void);

package/src/sync_timeline.mm

@@ -25,6 +25,13 @@ static CMTime g_cameraFirstTimestamp = kCMTimeInvalid;
 static CMTime g_audioHoldFirstTimestamp = kCMTimeInvalid;
 static BOOL g_audioHoldLogged = NO;
 
+// Primary-source start barrier (USB iPhone screen capture, etc.).
+static BOOL g_expectPrimary = NO;
+static BOOL g_primaryReady = YES;
+static CMTime g_primaryStartTimestamp = kCMTimeInvalid;
+static CMTime g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+static BOOL g_primaryHoldLogged = NO;
+
 void MRSyncConfigure(BOOL expectAudio) {
     dispatch_sync(MRSyncQueue(), ^{
         g_expectAudio = expectAudio;
@@ -40,6 +47,11 @@ void MRSyncConfigure(BOOL expectAudio) {
         g_cameraFirstTimestamp = kCMTimeInvalid;
         g_audioHoldFirstTimestamp = kCMTimeInvalid;
         g_audioHoldLogged = NO;
+        g_expectPrimary = NO;
+        g_primaryReady = YES;
+        g_primaryStartTimestamp = kCMTimeInvalid;
+        g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+        g_primaryHoldLogged = NO;
     });
 }
 
@@ -245,6 +257,82 @@ BOOL MRSyncShouldHoldAudioSample(CMTime timestamp) {
     return shouldHold;
 }
 
+void MRSyncConfigurePrimaryStart(BOOL expectPrimary) {
+    dispatch_sync(MRSyncQueue(), ^{
+        g_expectPrimary = expectPrimary;
+        g_primaryReady = expectPrimary ? NO : YES;
+        g_primaryStartTimestamp = kCMTimeInvalid;
+        g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+        g_primaryHoldLogged = NO;
+    });
+    if (expectPrimary) {
+        MRLog(@"🔄 A/V SYNC: Primary-source start barrier enabled");
+    }
+}
+
+void MRSyncMarkPrimaryStarted(CMTime timestamp) {
+    if (!CMTIME_IS_VALID(timestamp)) return;
+
+    __block BOOL logRelease = NO;
+    dispatch_sync(MRSyncQueue(), ^{
+        if (g_primaryReady) return;
+        g_primaryStartTimestamp = timestamp;
+        g_primaryReady = YES;
+        g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+        g_primaryHoldLogged = NO;
+        logRelease = YES;
+    });
+    if (logRelease) {
+        MRLog(@"🎯 A/V SYNC: Primary source started - releasing camera and microphone");
+    }
+}
+
+BOOL MRSyncShouldHoldForPrimary(CMTime timestamp) {
+    if (!CMTIME_IS_VALID(timestamp)) return NO;
+
+    __block BOOL shouldHold = NO;
+    __block BOOL logHold = NO;
+    __block BOOL logRelease = NO;
+    dispatch_sync(MRSyncQueue(), ^{
+        if (!g_expectPrimary || g_primaryReady) {
+            if (CMTIME_IS_VALID(g_primaryStartTimestamp) &&
+                CMTIME_COMPARE_INLINE(timestamp, <, g_primaryStartTimestamp)) {
+                shouldHold = YES;
+            }
+            return;
+        }
+
+        if (!CMTIME_IS_VALID(g_primaryHoldFirstTimestamp)) {
+            g_primaryHoldFirstTimestamp = timestamp;
+            shouldHold = YES;
+            if (!g_primaryHoldLogged) {
+                g_primaryHoldLogged = YES;
+                logHold = YES;
+            }
+            return;
+        }
+
+        // Fail open if a future primary source forgets to signal start.
+        CMTime elapsed = CMTimeSubtract(timestamp, g_primaryHoldFirstTimestamp);
+        if (CMTIME_COMPARE_INLINE(elapsed, >, CMTimeMakeWithSeconds(12.0, 600))) {
+            g_primaryReady = YES;
+            g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+            g_primaryHoldLogged = NO;
+            shouldHold = NO;
+            logRelease = YES;
+            return;
+        }
+        shouldHold = YES;
+    });
+
+    if (logHold) {
+        MRLog(@"⏸️ A/V SYNC: Camera/microphone waiting for primary source");
+    } else if (logRelease) {
+        MRLog(@"▶️ A/V SYNC: Primary-source hold released by safety timeout");
+    }
+    return shouldHold;
+}
+
 void MRSyncSetStopLimitSeconds(double seconds) {
     dispatch_sync(MRSyncQueue(), ^{
         g_stopLimitSeconds = seconds;

package/src/window_selector.mm

@@ -239,6 +239,7 @@ void updateOverlay();
 NSDictionary* getWindowUnderCursor(CGPoint point);
 NSArray* getAllSelectableWindows();
 bool bringWindowToFront(int windowId);
+bool activateWindowOwnerApp(int windowId);
 void cleanupRecordingPreview();
 bool showRecordingPreview(NSDictionary *windowInfo);
 bool hideRecordingPreview();
@@ -842,6 +843,61 @@ static void ApplyBrandButtonStyle(NSButton *button) {
 
 static WindowSelectorDelegate *g_delegate = nil;
 
+// Pencerenin SAHIBI UYGULAMAYI aktive eder.
+//
+// bringWindowToFront() yalnizca AXRaise + AXFocused yapar; bu pencereyi one
+// getirir ama uygulamayi AKTIF hale getirmez. Kayit basladiginda kaydedilen
+// uygulama pasif kalirsa "odagi kaybedince gizlen" davranisindaki pencereler
+// (iTerm2 hotkey window vb.) kendini gizler ve kayitta gorunmez. Pencere kaydi
+// baslarken hedef uygulama gercekten aktif olmalidir ki kullanici icine
+// yazabilsin.
+bool activateWindowOwnerApp(int windowId) {
+    @autoreleasepool {
+        @try {
+            CFArrayRef cgWindowList = CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
+            if (!cgWindowList) return false;
+
+            NSArray *windowArray = (__bridge NSArray *)cgWindowList;
+            pid_t ownerPid = 0;
+            for (NSDictionary *windowInfo in windowArray) {
+                NSNumber *cgWindowId = [windowInfo objectForKey:(NSString *)kCGWindowNumber];
+                if ([cgWindowId intValue] == windowId) {
+                    NSNumber *processId = [windowInfo objectForKey:(NSString *)kCGWindowOwnerPID];
+                    ownerPid = (pid_t)[processId intValue];
+                    break;
+                }
+            }
+            CFRelease(cgWindowList);
+
+            if (ownerPid <= 0) {
+                NSLog(@"⚠️ activateWindowOwnerApp: window %d icin PID bulunamadi", windowId);
+                return false;
+            }
+
+            NSRunningApplication *app =
+                [NSRunningApplication runningApplicationWithProcessIdentifier:ownerPid];
+            if (!app) {
+                NSLog(@"⚠️ activateWindowOwnerApp: PID %d icin uygulama yok", ownerPid);
+                return false;
+            }
+
+            // Once uygulamayi aktive et, sonra hedef pencereyi one kaldir.
+            // Ters sirada yapilirsa aktivasyon uygulamanin kendi ana penceresini
+            // one getirip secilen pencereyi geri plana itebiliyor.
+            BOOL activated = [app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
+            NSLog(@"🔝 activateWindowOwnerApp: PID %d aktive=%d (window %d)",
+                  ownerPid, activated, windowId);
+
+            bringWindowToFront(windowId);
+            return activated ? true : false;
+
+        } @catch (NSException *exception) {
+            NSLog(@"❌ activateWindowOwnerApp exception: %@", exception.reason);
+            return false;
+        }
+    }
+}
+
 // Bring window to front using Accessibility API
 bool bringWindowToFront(int windowId) {
     @autoreleasepool {
@@ -2696,6 +2752,24 @@ Napi::Value BringWindowToFront(const Napi::CallbackInfo& info) {
     }
 }
 
+// NAPI Function: Pencerenin sahibi uygulamayi aktive et (pencere kaydi icin)
+Napi::Value ActivateWindowOwnerApp(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Window ID required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    int windowId = info[0].As<Napi::Number>().Int32Value();
+
+    @try {
+        return Napi::Boolean::New(env, activateWindowOwnerApp(windowId));
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
 // NAPI Function: Enable/Disable Auto Bring To Front
 Napi::Value SetBringToFrontEnabled(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -2937,6 +3011,7 @@ Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports) {
     exports.Set("getSelectedWindowInfo", Napi::Function::New(env, GetSelectedWindowInfo));
     exports.Set("getWindowSelectionStatus", Napi::Function::New(env, GetWindowSelectionStatus));
     exports.Set("bringWindowToFront", Napi::Function::New(env, BringWindowToFront));
+    exports.Set("activateWindowOwnerApp", Napi::Function::New(env, ActivateWindowOwnerApp));
     exports.Set("setBringToFrontEnabled", Napi::Function::New(env, SetBringToFrontEnabled));
     exports.Set("showRecordingPreview", Napi::Function::New(env, ShowRecordingPreview));
     exports.Set("hideRecordingPreview", Napi::Function::New(env, HideRecordingPreview));