node-mac-recorder 1.17.0 → 2.0.0

package/binding.gyp

@@ -5,6 +5,7 @@
       "sources": [
         "src/mac_recorder.mm",
         "src/screen_capture.mm",
+        "src/screen_capture_kit.mm",
         "src/audio_capture.mm",
         "src/cursor_tracker.mm",
         "src/window_selector.mm"

package/index.js

@@ -2,19 +2,24 @@ const { EventEmitter } = require("events");
 const path = require("path");
 const fs = require("fs");
 
-// Native modülü yükle
+// Native modülü yükle (prebuilt > local build fallback)
 let nativeBinding;
 try {
-	nativeBinding = require("./build/Release/mac_recorder.node");
-} catch (error) {
+	// Prebuilt
+	nativeBinding = require("node-gyp-build")(__dirname);
+} catch (e) {
 	try {
-		nativeBinding = require("./build/Debug/mac_recorder.node");
-	} catch (debugError) {
-		throw new Error(
-			'Native module not found. Please run "npm run build" to compile the native module.\n' +
-				"Original error: " +
-				error.message
-		);
+		nativeBinding = require("./build/Release/mac_recorder.node");
+	} catch (error) {
+		try {
+			nativeBinding = require("./build/Debug/mac_recorder.node");
+		} catch (debugError) {
+			throw new Error(
+				'Native module not found. Please run "npm run build" to compile the native module.\n' +
+					"Original error: " +
+					(error?.message || e?.message)
+			);
+		}
 	}
 }
 
@@ -45,6 +50,12 @@ class MacRecorder extends EventEmitter {
 			showClicks: false,
 			displayId: null, // Hangi ekranı kaydedeceği (null = ana ekran)
 			windowId: null, // Hangi pencereyi kaydedeceği (null = tam ekran)
+			// SC (gizli, opsiyonel) - mevcut kullanıcıları bozmaz
+			useScreenCaptureKit: false,
+			excludedAppBundleIds: [],
+			excludedPIDs: [],
+			excludedWindowIds: [],
+			autoExcludeSelf: !!(process.versions && process.versions.electron),
 		};
 
 		// Display cache için async initialization
@@ -118,6 +129,14 @@ class MacRecorder extends EventEmitter {
 			audioDeviceId: options.audioDeviceId || null, // null = default device
 			systemAudioDeviceId: options.systemAudioDeviceId || null, // null = auto-detect system audio device
 			captureArea: options.captureArea || null,
+			useScreenCaptureKit: options.useScreenCaptureKit || false,
+			excludedAppBundleIds: options.excludedAppBundleIds || [],
+			excludedPIDs: options.excludedPIDs || [],
+			excludedWindowIds: options.excludedWindowIds || [],
+			autoExcludeSelf:
+				typeof options.autoExcludeSelf === "boolean"
+					? options.autoExcludeSelf
+					: !!(process.versions && process.versions.electron),
 		};
 	}
 
@@ -167,11 +186,12 @@ class MacRecorder extends EventEmitter {
 							targetDisplayId = display.id; // Use actual display ID, not array index
 							// Koordinatları display'e göre normalize et
 							adjustedX = targetWindow.x - display.x;
-							
+
 							// Y coordinate conversion: CGWindow (top-left) to AVFoundation (bottom-left)
 							// Overlay'deki dönüşümle aynı mantık: screenHeight - windowY - windowHeight
 							const displayHeight = parseInt(display.resolution.split("x")[1]);
-							const convertedY = displayHeight - targetWindow.y - targetWindow.height;
+							const convertedY =
+								displayHeight - targetWindow.y - targetWindow.height;
 							adjustedY = Math.max(0, convertedY - display.y);
 							break;
 						}
@@ -206,7 +226,9 @@ class MacRecorder extends EventEmitter {
 						this.options.displayId = targetDisplayId;
 
 						// Recording için display bilgisini sakla (cursor capture için)
-						const targetDisplay = displays.find(d => d.id === targetDisplayId);
+						const targetDisplay = displays.find(
+							(d) => d.id === targetDisplayId
+						);
 						this.recordingDisplayInfo = {
 							displayId: targetDisplayId,
 							x: targetDisplay.x,
@@ -239,7 +261,9 @@ class MacRecorder extends EventEmitter {
 		if (this.options.displayId !== null && !this.recordingDisplayInfo) {
 			try {
 				const displays = await this.getDisplays();
-				const targetDisplay = displays.find(d => d.id === this.options.displayId);
+				const targetDisplay = displays.find(
+					(d) => d.id === this.options.displayId
+				);
 				if (targetDisplay) {
 					this.recordingDisplayInfo = {
 						displayId: this.options.displayId,
@@ -273,6 +297,11 @@ class MacRecorder extends EventEmitter {
 					windowId: this.options.windowId || null, // null = tam ekran
 					audioDeviceId: this.options.audioDeviceId || null, // null = default device
 					systemAudioDeviceId: this.options.systemAudioDeviceId || null, // null = auto-detect system audio device
+					useScreenCaptureKit: this.options.useScreenCaptureKit || false,
+					excludedAppBundleIds: this.options.excludedAppBundleIds || [],
+					excludedPIDs: this.options.excludedPIDs || [],
+					excludedWindowIds: this.options.excludedWindowIds || [],
+					autoExcludeSelf: this.options.autoExcludeSelf === true,
 				};
 
 				// Manuel captureArea varsa onu kullan
@@ -285,10 +314,34 @@ class MacRecorder extends EventEmitter {
 					};
 				}
 
-				const success = nativeBinding.startRecording(
-					outputPath,
-					recordingOptions
-				);
+				// SC yolu: kullanıcıdan SC talebi varsa veya exclude listeleri doluysa ve SC mevcutsa otomatik kullan
+				let success;
+				try {
+					const wantsSC = !!(
+						this.options.useScreenCaptureKit ||
+						this.options.excludedAppBundleIds?.length ||
+						this.options.excludedPIDs?.length ||
+						this.options.excludedWindowIds?.length
+					);
+					const scAvailable =
+						typeof nativeBinding.isScreenCaptureKitAvailable === "function" &&
+						nativeBinding.isScreenCaptureKitAvailable();
+					if (wantsSC && scAvailable) {
+						const scOptions = {
+							...recordingOptions,
+							useScreenCaptureKit: true,
+						};
+						success = nativeBinding.startRecording(outputPath, scOptions);
+					} else {
+						success = nativeBinding.startRecording(
+							outputPath,
+							recordingOptions
+						);
+					}
+				} catch (e) {
+					// Fallback AVFoundation
+					success = nativeBinding.startRecording(outputPath, recordingOptions);
+				}
 
 				if (success) {
 					this.isRecording = true;
@@ -302,13 +355,52 @@ class MacRecorder extends EventEmitter {
 						this.emit("timeUpdate", elapsed);
 					}, 1000);
 
-					// Kayıt tam başladığı anda event emit et
-					this.emit("recordingStarted", {
-						outputPath: this.outputPath,
-						timestamp: this.recordingStartTime,
-						options: this.options
-					});
-					
+					// Native kayıt gerçekten başladığını kontrol etmek için polling başlat
+					let recordingStartedEmitted = false;
+					const checkRecordingStatus = setInterval(() => {
+						try {
+							const nativeStatus = nativeBinding.getRecordingStatus();
+							if (nativeStatus && !recordingStartedEmitted) {
+								recordingStartedEmitted = true;
+								clearInterval(checkRecordingStatus);
+
+								// Kayıt gerçekten başladığı anda event emit et
+								this.emit("recordingStarted", {
+									outputPath: this.outputPath,
+									timestamp: Date.now(), // Gerçek başlangıç zamanı
+									options: this.options,
+									nativeConfirmed: true,
+								});
+							}
+						} catch (error) {
+							// Native status check error - fallback
+							if (!recordingStartedEmitted) {
+								recordingStartedEmitted = true;
+								clearInterval(checkRecordingStatus);
+								this.emit("recordingStarted", {
+									outputPath: this.outputPath,
+									timestamp: this.recordingStartTime,
+									options: this.options,
+									nativeConfirmed: false,
+								});
+							}
+						}
+					}, 50); // Her 50ms kontrol et
+
+					// Timeout fallback - 5 saniye sonra hala başlamamışsa emit et
+					setTimeout(() => {
+						if (!recordingStartedEmitted) {
+							recordingStartedEmitted = true;
+							clearInterval(checkRecordingStatus);
+							this.emit("recordingStarted", {
+								outputPath: this.outputPath,
+								timestamp: this.recordingStartTime,
+								options: this.options,
+								nativeConfirmed: false,
+							});
+						}
+					}, 5000);
+
 					this.emit("started", this.outputPath);
 					resolve(this.outputPath);
 				} else {
@@ -549,7 +641,7 @@ class MacRecorder extends EventEmitter {
 				width: options.windowInfo.width,
 				height: options.windowInfo.height,
 				windowRelative: true,
-				windowInfo: options.windowInfo
+				windowInfo: options.windowInfo,
 			};
 		} else if (this.recordingDisplayInfo) {
 			// Recording başlatılmışsa o display'i kullan
@@ -605,7 +697,7 @@ class MacRecorder extends EventEmitter {
 							if (this.cursorDisplayInfo.windowRelative) {
 								// Window-relative koordinatlar
 								coordinateSystem = "window-relative";
-								
+
 								// Window bounds kontrolü - cursor window dışındaysa kaydetme
 								if (
 									x < 0 ||
@@ -618,7 +710,7 @@ class MacRecorder extends EventEmitter {
 							} else {
 								// Display-relative koordinatlar
 								coordinateSystem = "display-relative";
-								
+
 								// Display bounds kontrolü
 								if (
 									x < 0 ||
@@ -643,9 +735,9 @@ class MacRecorder extends EventEmitter {
 								windowInfo: {
 									width: this.cursorDisplayInfo.width,
 									height: this.cursorDisplayInfo.height,
-									originalWindow: this.cursorDisplayInfo.windowInfo
-								}
-							})
+									originalWindow: this.cursorDisplayInfo.windowInfo,
+								},
+							}),
 						};
 
 						// Sadece eventType değiştiğinde veya pozisyon değiştiğinde kaydet
@@ -892,6 +984,6 @@ class MacRecorder extends EventEmitter {
 }
 
 // WindowSelector modülünü de export edelim
-MacRecorder.WindowSelector = require('./window-selector');
+MacRecorder.WindowSelector = require("./window-selector");
 
 module.exports = MacRecorder;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "1.17.0",
+	"version": "2.0.0",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [
@@ -38,14 +38,19 @@
 		"build": "node-gyp build",
 		"rebuild": "node-gyp rebuild",
 		"clean": "node-gyp clean",
+		"prebuild:darwin:arm64": "prebuildify --napi --strip --platform darwin --arch arm64",
+		"prebuild:darwin:x64": "prebuildify --napi --strip --platform darwin --arch x64",
+		"prebuild": "npm run prebuild:darwin:arm64 && npm run prebuild:darwin:x64",
 		"test:window-selector": "node window-selector-test.js",
 		"example:window-selector": "node examples/window-selector-example.js"
 	},
 	"dependencies": {
-		"node-addon-api": "^7.0.0"
+		"node-addon-api": "^7.0.0",
+		"node-gyp-build": "^4.6.0"
 	},
 	"devDependencies": {
-		"node-gyp": "^10.0.0"
+		"node-gyp": "^10.0.0",
+		"prebuildify": "^5.0.0"
 	},
 	"gypfile": true
 }

package/src/mac_recorder.mm

@@ -9,6 +9,7 @@
 
 // Import screen capture
 #import "screen_capture.h"
+#import "screen_capture_kit.h"
 
 // Cursor tracker function declarations
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
@@ -67,7 +68,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     std::string outputPath = info[0].As<Napi::String>().Utf8Value();
     
-    // Options parsing
+    // Options parsing (shared)
     CGRect captureRect = CGRectNull;
     bool captureCursor = false; // Default olarak cursor gizli
     bool includeMicrophone = false; // Default olarak mikrofon kapalı
@@ -75,6 +76,12 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     CGDirectDisplayID displayID = CGMainDisplayID(); // Default ana ekran
     NSString *audioDeviceId = nil; // Default audio device ID
     NSString *systemAudioDeviceId = nil; // System audio device ID
+    bool forceUseSC = false;
+    // Exclude options for ScreenCaptureKit (optional, backward compatible)
+    NSMutableArray<NSString*> *excludedAppBundleIds = [NSMutableArray array];
+    NSMutableArray<NSNumber*> *excludedPIDs = [NSMutableArray array];
+    NSMutableArray<NSNumber*> *excludedWindowIds = [NSMutableArray array];
+    bool autoExcludeSelf = false;
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
@@ -118,6 +125,43 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             std::string sysDeviceId = options.Get("systemAudioDeviceId").As<Napi::String>().Utf8Value();
             systemAudioDeviceId = [NSString stringWithUTF8String:sysDeviceId.c_str()];
         }
+
+        // ScreenCaptureKit toggle (optional)
+        if (options.Has("useScreenCaptureKit")) {
+            forceUseSC = options.Get("useScreenCaptureKit").As<Napi::Boolean>();
+        }
+
+        // Exclusion lists (optional)
+        if (options.Has("excludedAppBundleIds") && options.Get("excludedAppBundleIds").IsArray()) {
+            Napi::Array arr = options.Get("excludedAppBundleIds").As<Napi::Array>();
+            for (uint32_t i = 0; i < arr.Length(); i++) {
+                if (!arr.Get(i).IsUndefined() && !arr.Get(i).IsNull()) {
+                    std::string s = arr.Get(i).As<Napi::String>().Utf8Value();
+                    [excludedAppBundleIds addObject:[NSString stringWithUTF8String:s.c_str()]];
+                }
+            }
+        }
+        if (options.Has("excludedPIDs") && options.Get("excludedPIDs").IsArray()) {
+            Napi::Array arr = options.Get("excludedPIDs").As<Napi::Array>();
+            for (uint32_t i = 0; i < arr.Length(); i++) {
+                if (!arr.Get(i).IsUndefined() && !arr.Get(i).IsNull()) {
+                    double v = arr.Get(i).As<Napi::Number>().DoubleValue();
+                    [excludedPIDs addObject:@( (pid_t)v )];
+                }
+            }
+        }
+        if (options.Has("excludedWindowIds") && options.Get("excludedWindowIds").IsArray()) {
+            Napi::Array arr = options.Get("excludedWindowIds").As<Napi::Array>();
+            for (uint32_t i = 0; i < arr.Length(); i++) {
+                if (!arr.Get(i).IsUndefined() && !arr.Get(i).IsNull()) {
+                    double v = arr.Get(i).As<Napi::Number>().DoubleValue();
+                    [excludedWindowIds addObject:@( (uint32_t)v )];
+                }
+            }
+        }
+        if (options.Has("autoExcludeSelf")) {
+            autoExcludeSelf = options.Get("autoExcludeSelf").As<Napi::Boolean>();
+        }
         
         // Display ID
         if (options.Has("displayId") && !options.Get("displayId").IsNull()) {
@@ -159,6 +203,43 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     }
     
     @try {
+        // Prefer ScreenCaptureKit if requested or if exclusion lists provided and available
+        bool wantsSC = forceUseSC || excludedAppBundleIds.count > 0 || excludedPIDs.count > 0 || excludedWindowIds.count > 0 || autoExcludeSelf;
+        if (wantsSC && [ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
+            NSMutableDictionary *scConfig = [@{} mutableCopy];
+            scConfig[@"displayId"] = @(displayID);
+            if (!CGRectIsNull(captureRect)) {
+                scConfig[@"captureArea"] = @{ @"x": @(captureRect.origin.x),
+                                               @"y": @(captureRect.origin.y),
+                                               @"width": @(captureRect.size.width),
+                                               @"height": @(captureRect.size.height) };
+            }
+            scConfig[@"captureCursor"] = @(captureCursor);
+            scConfig[@"includeMicrophone"] = @(includeMicrophone);
+            scConfig[@"includeSystemAudio"] = @(includeSystemAudio);
+            if (excludedAppBundleIds.count) scConfig[@"excludedAppBundleIds"] = excludedAppBundleIds;
+            if (excludedPIDs.count) scConfig[@"excludedPIDs"] = excludedPIDs;
+            if (excludedWindowIds.count) scConfig[@"excludedWindowIds"] = excludedWindowIds;
+            // Auto exclude current app by PID if requested
+            if (autoExcludeSelf) {
+                pid_t pid = getpid();
+                NSMutableArray *arr = [NSMutableArray arrayWithArray:scConfig[@"excludedPIDs"] ?: @[]];
+                [arr addObject:@(pid)];
+                scConfig[@"excludedPIDs"] = arr;
+            }
+
+            // Output path for SC
+            std::string outputPathStr = info[0].As<Napi::String>().Utf8Value();
+            scConfig[@"outputPath"] = [NSString stringWithUTF8String:outputPathStr.c_str()];
+
+            NSError *scErr = nil;
+            BOOL ok = [ScreenCaptureKitRecorder startRecordingWithConfiguration:scConfig delegate:nil error:&scErr];
+            if (ok) {
+                g_isRecording = true;
+                return Napi::Boolean::New(env, true);
+            }
+            // If SC failed, fall through to AVFoundation as fallback
+        }
         // Create capture session
         g_captureSession = [[AVCaptureSession alloc] init];
         [g_captureSession beginConfiguration];
@@ -325,14 +406,19 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
 Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    if (!g_isRecording || !g_movieFileOutput) {
+    if (!g_isRecording) {
         return Napi::Boolean::New(env, false);
     }
     
     @try {
-        [g_movieFileOutput stopRecording];
-        [g_captureSession stopRunning];
-        
+        if (g_movieFileOutput) {
+            [g_movieFileOutput stopRecording];
+            [g_captureSession stopRunning];
+            g_isRecording = false;
+            return Napi::Boolean::New(env, true);
+        }
+        // Try ScreenCaptureKit stop
+        [ScreenCaptureKitRecorder stopRecording];
         g_isRecording = false;
         return Napi::Boolean::New(env, true);
         
@@ -812,6 +898,12 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, GetWindows));
     exports.Set(Napi::String::New(env, "getRecordingStatus"), Napi::Function::New(env, GetRecordingStatus));
     exports.Set(Napi::String::New(env, "checkPermissions"), Napi::Function::New(env, CheckPermissions));
+    // ScreenCaptureKit availability (optional for clients)
+    exports.Set(Napi::String::New(env, "isScreenCaptureKitAvailable"), Napi::Function::New(env, [](const Napi::CallbackInfo& info){
+        Napi::Env env = info.Env();
+        bool available = [ScreenCaptureKitRecorder isScreenCaptureKitAvailable];
+        return Napi::Boolean::New(env, available);
+    }));
     
     // Thumbnail functions
     exports.Set(Napi::String::New(env, "getWindowThumbnail"), Napi::Function::New(env, GetWindowThumbnail));

package/src/screen_capture_kit.mm

@@ -0,0 +1,202 @@
+#import "screen_capture_kit.h"
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+#import <AVFoundation/AVFoundation.h>
+
+static SCStream *g_scStream = nil;
+static SCRecordingOutput *g_scRecordingOutput = nil;
+static NSURL *g_outputURL = nil;
+
+@interface ScreenCaptureKitRecorder () <SCRecordingOutputDelegate>
+@end
+
+@implementation ScreenCaptureKitRecorder
+
++ (BOOL)isScreenCaptureKitAvailable {
+    if (@available(macOS 14.0, *)) {
+        Class streamClass = NSClassFromString(@"SCStream");
+        Class recordingOutputClass = NSClassFromString(@"SCRecordingOutput");
+        return (streamClass != nil && recordingOutputClass != nil);
+    }
+    return NO;
+}
+
++ (BOOL)isRecording {
+    return g_scStream != nil;
+}
+
++ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config 
+                               delegate:(id)delegate 
+                                  error:(NSError **)error {
+    if (![self isScreenCaptureKitAvailable]) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"ScreenCaptureKitRecorder"
+                                         code:-1
+                                     userInfo:@{NSLocalizedDescriptionKey: @"ScreenCaptureKit not available"}];
+        }
+        return NO;
+    }
+
+    if (g_scStream) {
+        return NO;
+    }
+
+    @try {
+        __block SCShareableContent *content = nil;
+        __block NSError *contentErr = nil;
+
+        dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+        if (@available(macOS 13.0, *)) {
+            [SCShareableContent getShareableContentExcludingDesktopWindows:NO
+                                                    onScreenWindowsOnly:YES
+                                                          completionHandler:^(SCShareableContent * _Nullable shareableContent, NSError * _Nullable err) {
+                content = shareableContent;
+                contentErr = err;
+                dispatch_semaphore_signal(sem);
+            }];
+        } else {
+            dispatch_semaphore_signal(sem);
+        }
+        dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+
+        if (!content || contentErr) {
+            if (error) { *error = contentErr ?: [NSError errorWithDomain:@"ScreenCaptureKitRecorder" code:-2 userInfo:nil]; }
+            return NO;
+        }
+
+        NSNumber *displayIdNumber = config[@"displayId"]; // CGDirectDisplayID
+        NSDictionary *captureArea = config[@"captureArea"]; // {x,y,width,height}
+        NSNumber *captureCursorNum = config[@"captureCursor"];
+        NSNumber *includeMicNum = config[@"includeMicrophone"];
+        NSNumber *includeSystemAudioNum = config[@"includeSystemAudio"];
+        NSArray<NSString *> *excludedBundleIds = config[@"excludedAppBundleIds"];
+        NSArray<NSNumber *> *excludedPIDs = config[@"excludedPIDs"];
+        NSArray<NSNumber *> *excludedWindowIds = config[@"excludedWindowIds"];
+        NSString *outputPath = config[@"outputPath"];
+
+        SCDisplay *targetDisplay = nil;
+        if (displayIdNumber) {
+            uint32_t wanted = (uint32_t)displayIdNumber.unsignedIntValue;
+            for (SCDisplay *d in content.displays) {
+                if (d.displayID == wanted) { targetDisplay = d; break; }
+            }
+        }
+        if (!targetDisplay) {
+            targetDisplay = content.displays.firstObject;
+            if (!targetDisplay) { return NO; }
+        }
+
+        NSMutableArray<SCRunningApplication*> *appsToExclude = [NSMutableArray array];
+        if (excludedBundleIds.count > 0) {
+            for (SCRunningApplication *app in content.applications) {
+                if ([excludedBundleIds containsObject:app.bundleIdentifier]) {
+                    [appsToExclude addObject:app];
+                }
+            }
+        }
+        if (excludedPIDs.count > 0) {
+            for (SCRunningApplication *app in content.applications) {
+                if ([excludedPIDs containsObject:@(app.processID)]) {
+                    [appsToExclude addObject:app];
+                }
+            }
+        }
+
+        NSMutableArray<SCWindow*> *windowsToExclude = [NSMutableArray array];
+        if (excludedWindowIds.count > 0) {
+            for (SCWindow *w in content.windows) {
+                if ([excludedWindowIds containsObject:@(w.windowID)]) {
+                    [windowsToExclude addObject:w];
+                }
+            }
+        }
+
+        SCContentFilter *filter = nil;
+        if (appsToExclude.count > 0) {
+            if (@available(macOS 13.0, *)) {
+                filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingApplications:appsToExclude exceptingWindows:windowsToExclude];
+            }
+        }
+        if (!filter) {
+            if (@available(macOS 13.0, *)) {
+                filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:windowsToExclude];
+            }
+        }
+        if (!filter) { return NO; }
+
+        SCStreamConfiguration *cfg = [[SCStreamConfiguration alloc] init];
+        if (captureArea && captureArea[@"width"] && captureArea[@"height"]) {
+            CGRect src = CGRectMake([captureArea[@"x"] doubleValue],
+                                    [captureArea[@"y"] doubleValue],
+                                    [captureArea[@"width"] doubleValue],
+                                    [captureArea[@"height"] doubleValue]);
+            cfg.sourceRect = src;
+            cfg.width = (int)src.size.width;
+            cfg.height = (int)src.size.height;
+        } else {
+            cfg.width = (int)targetDisplay.width;
+            cfg.height = (int)targetDisplay.height;
+        }
+        cfg.showsCursor = captureCursorNum.boolValue;
+        if (includeMicNum || includeSystemAudioNum) {
+            cfg.capturesAudio = YES;
+        }
+
+        g_scStream = [[SCStream alloc] initWithFilter:filter configuration:cfg delegate:nil];
+
+        if (@available(macOS 14.0, *)) {
+            SCRecordingOutputConfiguration *recCfg = [[SCRecordingOutputConfiguration alloc] init];
+            g_outputURL = [NSURL fileURLWithPath:outputPath];
+            recCfg.outputURL = g_outputURL;
+            recCfg.outputFileType = AVFileTypeQuickTimeMovie;
+            g_scRecordingOutput = [[SCRecordingOutput alloc] initWithConfiguration:recCfg delegate:(id<SCRecordingOutputDelegate>)delegate ?: (id<SCRecordingOutputDelegate>)self];
+            NSError *addErr = nil;
+            BOOL added = [g_scStream addRecordingOutput:g_scRecordingOutput error:&addErr];
+            if (!added) {
+                if (error) { *error = addErr ?: [NSError errorWithDomain:@"ScreenCaptureKitRecorder" code:-3 userInfo:nil]; }
+                g_scRecordingOutput = nil; g_scStream = nil; g_outputURL = nil;
+                return NO;
+            }
+
+            __block NSError *startErr = nil;
+            dispatch_semaphore_t startSem = dispatch_semaphore_create(0);
+            [g_scStream startCaptureWithCompletionHandler:^(NSError * _Nullable err) {
+                startErr = err;
+                dispatch_semaphore_signal(startSem);
+            }];
+            dispatch_semaphore_wait(startSem, DISPATCH_TIME_FOREVER);
+            if (startErr) {
+                if (error) { *error = startErr; }
+                [g_scStream removeRecordingOutput:g_scRecordingOutput error:nil];
+                g_scRecordingOutput = nil; g_scStream = nil; g_outputURL = nil;
+                return NO;
+            }
+            return YES;
+        }
+
+        return NO;
+    } @catch (__unused NSException *ex) {
+        return NO;
+    }
+}
+
++ (void)stopRecording {
+    if (!g_scStream) { return; }
+    @try {
+        dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+        [g_scStream stopCaptureWithCompletionHandler:^(NSError * _Nullable error) {
+            dispatch_semaphore_signal(sem);
+        }];
+        dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+    } @catch (__unused NSException *ex) {
+    }
+    if (g_scRecordingOutput) {
+        [g_scStream removeRecordingOutput:g_scRecordingOutput error:nil];
+    }
+    g_scRecordingOutput = nil;
+    g_scStream = nil;
+    g_outputURL = nil;
+}
+
+@end
+
+