node-mac-recorder 1.5.0 → 1.6.0

package/WINDOW_SELECTOR_README.md

@@ -14,6 +14,9 @@ Bu modül, macOS'ta sistem imleci ile pencere seçimi yapabilmenizi sağlayan g
 - **Event-driven API**: Pencere hover, seçim ve hata durumları için event'ler
 - **Window Focus Control**: Detect edilen pencereyi otomatik olarak en öne getirir
 - **Auto Bring-to-Front**: Cursor hangi pencereye gelirse otomatik focus yapar
+- **Recording Preview Overlay**: Kayıt alanını görselleştiren tam ekran overlay sistemi
+- **Screen Selection**: Tam ekran overlay ile ekran seçimi (menu bar dahil)
+- **Screen Recording Preview**: Seçilen ekran için kayıt önizleme sistemi
 - **Permission Management**: macOS izin kontrolü ve yönetimi
 
 ## 🚀 Kurulum
@@ -175,6 +178,84 @@ selector.setBringToFrontEnabled(true);  // Auto mode ON
 selector.setBringToFrontEnabled(false); // Auto mode OFF
 ```
 
+##### `async showRecordingPreview(windowInfo)`
+Seçilen pencere için kayıt önizleme overlay'ini gösterir. Tüm ekranı siyah yapar, sadece pencere alanını şeffaf bırakır.
+
+**Parameters:**
+- `windowInfo` (WindowInfo) - Pencere bilgileri
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.showRecordingPreview(selectedWindow);
+```
+
+##### `async hideRecordingPreview()`
+Kayıt önizleme overlay'ini gizler.
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.hideRecordingPreview();
+```
+
+##### `async startScreenSelection()`
+Ekran seçim modunu başlatır. Tüm ekranları overlay ile gösterir.
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.startScreenSelection();
+```
+
+##### `async stopScreenSelection()`
+Ekran seçim modunu durdurur.
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.stopScreenSelection();
+```
+
+##### `getSelectedScreen()`
+Son seçilen ekran bilgisini döndürür.
+
+**Returns:** `ScreenInfo | null`
+
+```javascript
+const screenInfo = selector.getSelectedScreen();
+```
+
+##### `async selectScreen()`
+Promise tabanlı ekran seçimi. Kullanıcı bir ekran seçene kadar bekler.
+
+**Returns:** `Promise<ScreenInfo>`
+
+```javascript
+const selectedScreen = await selector.selectScreen();
+```
+
+##### `async showScreenRecordingPreview(screenInfo)`
+Seçilen ekran için kayıt önizleme overlay'ini gösterir. Diğer ekranları siyah yapar, sadece seçili ekranı şeffaf bırakır.
+
+**Parameters:**
+- `screenInfo` (ScreenInfo) - Ekran bilgileri
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.showScreenRecordingPreview(selectedScreen);
+```
+
+##### `async hideScreenRecordingPreview()`
+Ekran kayıt önizleme overlay'ini gizler.
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.hideScreenRecordingPreview();
+```
+
 ##### `async cleanup()`
 Tüm kaynakları temizler ve seçimi durdurur.
 
@@ -267,6 +348,20 @@ selector.on('error', (error) => {
 }
 ```
 
+### ScreenInfo
+```javascript
+{
+    id: number,          // Ekran ID'si (0, 1, 2, ...)
+    name: string,        // Ekran adı ("Display 1", "Display 2", ...)
+    x: number,          // Global X pozisyonu
+    y: number,          // Global Y pozisyonu
+    width: number,      // Ekran genişliği
+    height: number,     // Ekran yüksekliği
+    resolution: string, // Çözünürlük string'i ("1920x1080")
+    isPrimary: boolean  // Ana ekran mı?
+}
+```
+
 ## 🎮 Test Etme
 
 ### Test Dosyasını Çalıştır
@@ -298,6 +393,7 @@ node examples/window-selector-example.js --help
 
 ## ⚡ Nasıl Çalışır?
 
+### Pencere Seçim Süreci
 1. **Window Detection**: macOS `CGWindowListCopyWindowInfo` API'si ile açık pencereleri tespit eder
 2. **Cursor Tracking**: Real-time olarak imleç pozisyonunu takip eder
 3. **Overlay Rendering**: NSWindow ile transparant overlay penceresi oluşturur
@@ -306,6 +402,29 @@ node examples/window-selector-example.js --help
 6. **User Interaction**: Merkeze yerleştirilen button ile seçim yapar
 7. **Data Collection**: Seçilen pencerenin tüm bilgilerini toplar
 
+### Kayıt Önizleme Sistemi (Pencere)
+1. **Full Screen Overlay**: Tüm ekranı kaplayan siyah transparan katman oluşturur
+2. **Window Cutout**: Seçilen pencere alanını şeffaf hale getirir (cut-out effect)
+3. **Coordinate Conversion**: CGWindow koordinatlarını NSView koordinatlarına dönüştürür  
+4. **Multi-Display Support**: Çoklu ekran kurulumlarında doğru pozisyonlama yapar
+5. **Non-Interactive**: Mouse events'leri geçirir, kullanıcı etkileşimini engellemeZ
+6. **Clean Management**: Programatik açma/kapama kontrolü sağlar
+
+### Ekran Seçim Sistemi
+1. **Multi-Screen Detection**: NSScreen.screens ile tüm ekranları tespit eder
+2. **Full Screen Coverage**: Her ekran için tam kaplama overlay oluşturur (menu bar dahil)
+3. **Interactive Overlays**: Her ekranda merkezi "Select Screen" butonu
+4. **Screen Information Display**: Ekran adı ve çözünürlük bilgilerini gösterir
+5. **Automatic Assignment**: Her overlay'i kendi ekranına otomatik atar
+6. **Selection Feedback**: Seçim yapıldığında anında geri bildirim
+
+### Ekran Kayıt Önizleme Sistemi
+1. **Multi-Screen Management**: Birden fazla ekranı aynı anda yönetir
+2. **Selective Darkening**: Sadece seçilmeyen ekranları siyah overlay ile kaplar
+3. **Recording Area Highlight**: Seçilen ekran tamamen şeffaf kalır
+4. **Screen-Specific Overlays**: Her ekran için ayrı overlay penceresi
+5. **Coordinate Independence**: Her ekranın kendi koordinat sistemini kullanır
+
 ## 🔧 Troubleshooting
 
 ### Build Hataları
@@ -375,7 +494,157 @@ async function manualFocus() {
 }
 ```
 
-### Otomatik Pencere Kaydı
+### Ekran Seçimi ile Kayıt
+```javascript
+const WindowSelector = require('./window-selector');
+const MacRecorder = require('./index');
+
+async function recordScreenWithPreview() {
+    const selector = new WindowSelector();
+    const recorder = new MacRecorder();
+    
+    try {
+        // Ekran seç
+        const screen = await selector.selectScreen();
+        console.log(`Selected: ${screen.name} (${screen.resolution})`);
+        
+        // Kayıt önizlemesi göster (diğer ekranlar siyah, seçili ekran şeffaf)
+        await selector.showScreenRecordingPreview(screen);
+        console.log('🎬 Screen recording preview shown');
+        
+        // 3 saniye bekle
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        
+        // Ekran kaydını başlat
+        const outputPath = `./recordings/screen-${screen.id}-${Date.now()}.mov`;
+        await recorder.startRecording(outputPath, {
+            displayId: screen.id,
+            captureCursor: true,
+            includeMicrophone: true
+        });
+        
+        console.log('🔴 Screen recording started...');
+        
+        // 10 saniye kaydet
+        setTimeout(async () => {
+            await recorder.stopRecording();
+            
+            // Önizleme overlay'ini gizle
+            await selector.hideScreenRecordingPreview();
+            console.log(`✅ Recording saved: ${outputPath}`);
+        }, 10000);
+        
+    } finally {
+        await selector.cleanup();
+    }
+}
+```
+
+### Kayıt Önizleme ile Pencere Kaydı
+```javascript
+const WindowSelector = require('./window-selector');
+const MacRecorder = require('./index');
+
+async function recordWithPreview() {
+    const selector = new WindowSelector();
+    const recorder = new MacRecorder();
+    
+    try {
+        // Pencere seç
+        const window = await selector.selectWindow();
+        console.log(`Selected: ${window.title}`);
+        
+        // Kayıt önizlemesi göster (siyah overlay + şeffaf pencere alanı)
+        await selector.showRecordingPreview(window);
+        console.log('🎬 Recording preview shown - you can see exact recording area');
+        
+        // 3 saniye bekle (kullanıcı görebilsin)
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        
+        // Kaydı başlat
+        const outputPath = `./recordings/${window.appName}-${Date.now()}.mov`;
+        await recorder.startRecording(outputPath, {
+            windowId: window.id,
+            captureCursor: true,
+            includeMicrophone: true
+        });
+        
+        console.log('🔴 Recording started...');
+        
+        // 10 saniye kaydet
+        setTimeout(async () => {
+            await recorder.stopRecording();
+            
+            // Önizleme overlay'ini gizle
+            await selector.hideRecordingPreview();
+            console.log(`✅ Recording saved: ${outputPath}`);
+        }, 10000);
+        
+    } finally {
+        await selector.cleanup();
+    }
+}
+```
+
+### Basit Ekran Seçimi
+```javascript
+const WindowSelector = require('./window-selector');
+
+async function selectScreen() {
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('Bir ekran seçin...');
+        const selectedScreen = await selector.selectScreen();
+        
+        console.log('Seçilen ekran:', {
+            name: selectedScreen.name,
+            resolution: selectedScreen.resolution,
+            position: `(${selectedScreen.x}, ${selectedScreen.y})`,
+            isPrimary: selectedScreen.isPrimary
+        });
+        
+        return selectedScreen;
+        
+    } catch (error) {
+        console.error('Hata:', error.message);
+    } finally {
+        await selector.cleanup();
+    }
+}
+```
+
+### Manuel Ekran Kontrolü
+```javascript
+const WindowSelector = require('./window-selector');
+
+async function manualScreenSelection() {
+    const selector = new WindowSelector();
+    
+    try {
+        // Ekran seçimini başlat
+        await selector.startScreenSelection();
+        console.log('🖥️ Screen overlays shown - click Select Screen button');
+        
+        // Polling ile seçim bekle
+        const checkSelection = () => {
+            const selected = selector.getSelectedScreen();
+            if (selected) {
+                console.log(`✅ Screen selected: ${selected.name}`);
+                return selected;
+            }
+            setTimeout(checkSelection, 100);
+        };
+        
+        checkSelection();
+        
+    } catch (error) {
+        console.error('Hata:', error.message);
+    }
+}
+```
+
+### Otomatik Pencere Kaydı (Basit)
 ```javascript
 const WindowSelector = require('./window-selector');
 const MacRecorder = require('./index');
@@ -450,6 +719,7 @@ Bu modül ana projenin lisansı altındadır.
 
 ## ⭐ Özellik İstekleri
 
+### Pencere Seçimi
 - [ ] Pencere gruplandırma
 - [ ] Hotkey desteği  
 - [ ] Pencere filtreleme
@@ -457,6 +727,14 @@ Bu modül ana projenin lisansı altındadır.
 - [ ] Screenshot alma
 - [ ] Window history
 
+### Ekran Seçimi
+- [x] Tam ekran overlay (menu bar dahil) ✅
+- [x] Multi-display desteği ✅
+- [x] Kayıt önizleme sistemi ✅
+- [ ] Hotkey desteği
+- [ ] Çoklu ekran seçimi
+- [ ] Ekran thumbnail'ları
+
 ---
 
 **Not**: Bu modül sadece macOS'ta çalışır ve sistem izinleri gerektirir.

package/package.json

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

package/src/window_selector.mm

@@ -17,12 +17,32 @@ static NSMutableArray *g_allWindows = nil;
 static NSDictionary *g_currentWindowUnderCursor = nil;
 static bool g_bringToFrontEnabled = true; // Default enabled
 
+// Recording preview overlay state
+static NSWindow *g_recordingPreviewWindow = nil;
+static NSView *g_recordingPreviewView = nil;
+static NSDictionary *g_recordingWindowInfo = nil;
+
+// Screen selection overlay state
+static bool g_isScreenSelecting = false;
+static NSMutableArray *g_screenOverlayWindows = nil;
+static NSDictionary *g_selectedScreenInfo = nil;
+static NSArray *g_allScreens = nil;
+
 // Forward declarations
 void cleanupWindowSelector();
 void updateOverlay();
 NSDictionary* getWindowUnderCursor(CGPoint point);
 NSArray* getAllSelectableWindows();
 bool bringWindowToFront(int windowId);
+void cleanupRecordingPreview();
+bool showRecordingPreview(NSDictionary *windowInfo);
+bool hideRecordingPreview();
+void cleanupScreenSelector();
+bool startScreenSelection();
+bool stopScreenSelection();
+NSDictionary* getSelectedScreenInfo();
+bool showScreenRecordingPreview(NSDictionary *screenInfo);
+bool hideScreenRecordingPreview();
 
 // Custom overlay view class
 @interface WindowSelectorOverlayView : NSView
@@ -35,7 +55,7 @@ bool bringWindowToFront(int windowId);
     self = [super initWithFrame:frameRect];
     if (self) {
         self.wantsLayer = YES;
-        self.layer.backgroundColor = [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.6] CGColor];
+        self.layer.backgroundColor = [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.45] CGColor];
         self.layer.borderColor = [[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor];
         self.layer.borderWidth = 5.0;
         self.layer.cornerRadius = 8.0;
@@ -49,7 +69,7 @@ bool bringWindowToFront(int windowId);
     if (!self.windowInfo) return;
     
     // Background with transparency
-    [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.6] setFill];
+    [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.45] setFill];
     NSRectFill(dirtyRect);
     
     // Border
@@ -80,9 +100,116 @@ bool bringWindowToFront(int windowId);
 
 @end
 
+// Recording preview overlay view - full screen with cutout
+@interface RecordingPreviewView : NSView
+@property (nonatomic, strong) NSDictionary *recordingWindowInfo;
+@end
+
+@implementation RecordingPreviewView
+
+- (instancetype)initWithFrame:(NSRect)frameRect {
+    self = [super initWithFrame:frameRect];
+    if (self) {
+        self.wantsLayer = YES;
+        self.layer.backgroundColor = [[NSColor clearColor] CGColor];
+    }
+    return self;
+}
+
+- (void)drawRect:(NSRect)dirtyRect {
+    [super drawRect:dirtyRect];
+    
+    if (!self.recordingWindowInfo) {
+        // No window info, fill with semi-transparent black
+        [[NSColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:0.5] setFill];
+        NSRectFill(dirtyRect);
+        return;
+    }
+    
+    // Get window coordinates
+    int windowX = [[self.recordingWindowInfo objectForKey:@"x"] intValue];
+    int windowY = [[self.recordingWindowInfo objectForKey:@"y"] intValue];
+    int windowWidth = [[self.recordingWindowInfo objectForKey:@"width"] intValue];
+    int windowHeight = [[self.recordingWindowInfo objectForKey:@"height"] intValue];
+    
+    // Convert from CGWindow coordinates (top-left) to NSView coordinates (bottom-left)
+    NSScreen *mainScreen = [NSScreen mainScreen];
+    CGFloat screenHeight = [mainScreen frame].size.height;
+    CGFloat convertedY = screenHeight - windowY - windowHeight;
+    
+    NSRect windowRect = NSMakeRect(windowX, convertedY, windowWidth, windowHeight);
+    
+    // Fill entire view with semi-transparent black
+    [[NSColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:0.5] setFill];
+    NSRectFill(self.bounds);
+    
+    // Cut out the window area (make it transparent)
+    [[NSColor clearColor] setFill];
+    NSRectFill(windowRect);
+}
+
+@end
+
+// Screen selection overlay view
+@interface ScreenSelectorOverlayView : NSView
+@property (nonatomic, strong) NSDictionary *screenInfo;
+@end
+
+@implementation ScreenSelectorOverlayView
+
+- (instancetype)initWithFrame:(NSRect)frameRect {
+    self = [super initWithFrame:frameRect];
+    if (self) {
+        self.wantsLayer = YES;
+        self.layer.backgroundColor = [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.45] CGColor];
+        self.layer.borderColor = [[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor];
+        self.layer.borderWidth = 5.0;
+        self.layer.cornerRadius = 8.0;
+    }
+    return self;
+}
+
+- (void)drawRect:(NSRect)dirtyRect {
+    [super drawRect:dirtyRect];
+    
+    if (!self.screenInfo) return;
+    
+    // Background with transparency
+    [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.45] setFill];
+    NSRectFill(dirtyRect);
+    
+    // Border
+    [[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] setStroke];
+    NSBezierPath *border = [NSBezierPath bezierPathWithRoundedRect:self.bounds xRadius:8 yRadius:8];
+    [border setLineWidth:3.0];
+    [border stroke];
+    
+    // Screen info text
+    NSString *screenName = [self.screenInfo objectForKey:@"name"] ?: @"Unknown Screen";
+    NSString *resolution = [self.screenInfo objectForKey:@"resolution"] ?: @"Unknown Resolution";
+    NSString *infoText = [NSString stringWithFormat:@"%@\n%@", screenName, resolution];
+    
+    NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
+    [style setAlignment:NSTextAlignmentCenter];
+    
+    NSDictionary *attributes = @{
+        NSFontAttributeName: [NSFont systemFontOfSize:21 weight:NSFontWeightMedium],
+        NSForegroundColorAttributeName: [NSColor whiteColor],
+        NSParagraphStyleAttributeName: style,
+        NSStrokeColorAttributeName: [NSColor blackColor],
+        NSStrokeWidthAttributeName: @(-2.0)
+    };
+    
+    NSRect textRect = NSMakeRect(10, self.bounds.size.height - 90, self.bounds.size.width - 20, 80);
+    [infoText drawInRect:textRect withAttributes:attributes];
+}
+
+@end
+
 // Button action handler and timer target
 @interface WindowSelectorDelegate : NSObject
 - (void)selectButtonClicked:(id)sender;
+- (void)screenSelectButtonClicked:(id)sender;
 - (void)timerUpdate:(NSTimer *)timer;
 @end
 
@@ -94,6 +221,18 @@ bool bringWindowToFront(int windowId);
     }
 }
 
+- (void)screenSelectButtonClicked:(id)sender {
+    // Get the screen info from the button's superview
+    NSView *overlayView = [[sender superview] superview];
+    if ([overlayView isKindOfClass:[ScreenSelectorOverlayView class]]) {
+        ScreenSelectorOverlayView *screenView = (ScreenSelectorOverlayView *)overlayView;
+        if (screenView.screenInfo) {
+            g_selectedScreenInfo = [screenView.screenInfo retain];
+            cleanupScreenSelector();
+        }
+    }
+}
+
 - (void)timerUpdate:(NSTimer *)timer {
     updateOverlay();
 }
@@ -313,7 +452,14 @@ void updateOverlay() {
             CGFloat screenHeight = [mainScreen frame].size.height;
             CGFloat adjustedY = screenHeight - y - height;
             
-            NSRect overlayFrame = NSMakeRect(x, adjustedY, width, height);
+            // Clamp overlay to screen bounds to avoid partial off-screen issues
+            NSRect screenFrame = [mainScreen frame];
+            CGFloat clampedX = MAX(screenFrame.origin.x, MIN(x, screenFrame.origin.x + screenFrame.size.width - width));
+            CGFloat clampedY = MAX(screenFrame.origin.y, MIN(adjustedY, screenFrame.origin.y + screenFrame.size.height - height));
+            CGFloat clampedWidth = MIN(width, screenFrame.size.width - (clampedX - screenFrame.origin.x));
+            CGFloat clampedHeight = MIN(height, screenFrame.size.height - (clampedY - screenFrame.origin.y));
+            
+            NSRect overlayFrame = NSMakeRect(clampedX, clampedY, clampedWidth, clampedHeight);
             
             NSString *windowTitle = [windowUnderCursor objectForKey:@"title"] ?: @"Untitled";
             NSString *appName = [windowUnderCursor objectForKey:@"appName"] ?: @"Unknown";
@@ -407,6 +553,288 @@ void cleanupWindowSelector() {
     }
 }
 
+// Recording preview functions
+void cleanupRecordingPreview() {
+    if (g_recordingPreviewWindow) {
+        [g_recordingPreviewWindow close];
+        g_recordingPreviewWindow = nil;
+        g_recordingPreviewView = nil;
+    }
+    
+    if (g_recordingWindowInfo) {
+        [g_recordingWindowInfo release];
+        g_recordingWindowInfo = nil;
+    }
+}
+
+bool showRecordingPreview(NSDictionary *windowInfo) {
+    @try {
+        // Clean up any existing preview
+        cleanupRecordingPreview();
+        
+        if (!windowInfo) return false;
+        
+        // Store window info
+        g_recordingWindowInfo = [windowInfo retain];
+        
+        // Get main screen bounds for full screen overlay
+        NSScreen *mainScreen = [NSScreen mainScreen];
+        NSRect screenFrame = [mainScreen frame];
+        
+        // Create full-screen overlay window
+        g_recordingPreviewWindow = [[NSWindow alloc] initWithContentRect:screenFrame
+                                                              styleMask:NSWindowStyleMaskBorderless
+                                                                backing:NSBackingStoreBuffered
+                                                                  defer:NO];
+        
+        [g_recordingPreviewWindow setLevel:CGWindowLevelForKey(kCGOverlayWindowLevelKey)]; // High level but below selection
+        [g_recordingPreviewWindow setOpaque:NO];
+        [g_recordingPreviewWindow setBackgroundColor:[NSColor clearColor]];
+        [g_recordingPreviewWindow setIgnoresMouseEvents:YES]; // Don't interfere with user interaction
+        [g_recordingPreviewWindow setAcceptsMouseMovedEvents:NO];
+        [g_recordingPreviewWindow setHasShadow:NO];
+        [g_recordingPreviewWindow setAlphaValue:1.0];
+        [g_recordingPreviewWindow setCollectionBehavior:NSWindowCollectionBehaviorStationary | NSWindowCollectionBehaviorCanJoinAllSpaces];
+        
+        // Create preview view
+        g_recordingPreviewView = [[RecordingPreviewView alloc] initWithFrame:screenFrame];
+        [(RecordingPreviewView *)g_recordingPreviewView setRecordingWindowInfo:windowInfo];
+        [g_recordingPreviewWindow setContentView:g_recordingPreviewView];
+        
+        // Show the preview
+        [g_recordingPreviewWindow orderFront:nil];
+        [g_recordingPreviewWindow makeKeyAndOrderFront:nil];
+        
+        NSLog(@"🎬 RECORDING PREVIEW: Showing overlay for %@ - \"%@\"", 
+              [windowInfo objectForKey:@"appName"],
+              [windowInfo objectForKey:@"title"]);
+        
+        return true;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Error showing recording preview: %@", exception);
+        cleanupRecordingPreview();
+        return false;
+    }
+}
+
+bool hideRecordingPreview() {
+    @try {
+        if (g_recordingPreviewWindow) {
+            NSLog(@"🎬 RECORDING PREVIEW: Hiding overlay");
+            cleanupRecordingPreview();
+            return true;
+        }
+        return false;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Error hiding recording preview: %@", exception);
+        return false;
+    }
+}
+
+// Screen selection functions
+void cleanupScreenSelector() {
+    g_isScreenSelecting = false;
+    
+    // Close all screen overlay windows
+    if (g_screenOverlayWindows) {
+        for (NSWindow *overlayWindow in g_screenOverlayWindows) {
+            [overlayWindow close];
+        }
+        [g_screenOverlayWindows release];
+        g_screenOverlayWindows = nil;
+    }
+    
+    // Clean up screen data
+    if (g_allScreens) {
+        [g_allScreens release];
+        g_allScreens = nil;
+    }
+}
+
+bool startScreenSelection() {
+    @try {
+        if (g_isScreenSelecting) return false;
+        
+        // Get all available screens
+        NSArray *screens = [NSScreen screens];
+        if (!screens || [screens count] == 0) return false;
+        
+        // Create screen info array
+        NSMutableArray *screenInfoArray = [[NSMutableArray alloc] init];
+        g_screenOverlayWindows = [[NSMutableArray alloc] init];
+        
+        for (NSInteger i = 0; i < [screens count]; i++) {
+            NSScreen *screen = [screens objectAtIndex:i];
+            NSRect screenFrame = [screen frame];
+            
+            // Create screen info dictionary
+            NSMutableDictionary *screenInfo = [[NSMutableDictionary alloc] init];
+            [screenInfo setObject:[NSNumber numberWithInteger:i] forKey:@"id"];
+            [screenInfo setObject:[NSString stringWithFormat:@"Display %ld", (long)(i + 1)] forKey:@"name"];
+            [screenInfo setObject:[NSNumber numberWithInt:(int)screenFrame.origin.x] forKey:@"x"];
+            [screenInfo setObject:[NSNumber numberWithInt:(int)screenFrame.origin.y] forKey:@"y"];
+            [screenInfo setObject:[NSNumber numberWithInt:(int)screenFrame.size.width] forKey:@"width"];
+            [screenInfo setObject:[NSNumber numberWithInt:(int)screenFrame.size.height] forKey:@"height"];
+            [screenInfo setObject:[NSString stringWithFormat:@"%.0fx%.0f", screenFrame.size.width, screenFrame.size.height] forKey:@"resolution"];
+            [screenInfo setObject:[NSNumber numberWithBool:(i == 0)] forKey:@"isPrimary"]; // First screen is primary
+            [screenInfoArray addObject:screenInfo];
+            
+            // Create overlay window for this screen (FULL screen including menu bar)
+            NSWindow *overlayWindow = [[NSWindow alloc] initWithContentRect:screenFrame
+                                                                  styleMask:NSWindowStyleMaskBorderless
+                                                                    backing:NSBackingStoreBuffered
+                                                                      defer:NO
+                                                                      screen:screen];
+            
+            [overlayWindow setLevel:CGWindowLevelForKey(kCGMaximumWindowLevelKey)];
+            [overlayWindow setOpaque:NO];
+            [overlayWindow setBackgroundColor:[NSColor clearColor]];
+            [overlayWindow setIgnoresMouseEvents:NO];
+            [overlayWindow setAcceptsMouseMovedEvents:YES];
+            [overlayWindow setHasShadow:NO];
+            [overlayWindow setAlphaValue:1.0];
+            [overlayWindow setCollectionBehavior:NSWindowCollectionBehaviorStationary | NSWindowCollectionBehaviorCanJoinAllSpaces];
+            
+            // Create overlay view
+            ScreenSelectorOverlayView *overlayView = [[ScreenSelectorOverlayView alloc] initWithFrame:screenFrame];
+            [overlayView setScreenInfo:screenInfo];
+            [overlayWindow setContentView:overlayView];
+            
+            // Create select button
+            NSButton *selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 180, 60)];
+            [selectButton setTitle:@"Select Screen"];
+            [selectButton setButtonType:NSButtonTypeMomentaryPushIn];
+            [selectButton setBezelStyle:NSBezelStyleRounded];
+            [selectButton setFont:[NSFont systemFontOfSize:16 weight:NSFontWeightSemibold]];
+            [selectButton setWantsLayer:NO]; // Use system default
+            
+            // Add shadow for better visibility
+            [selectButton.layer setShadowColor:[[NSColor blackColor] CGColor]];
+            [selectButton.layer setShadowOffset:NSMakeSize(0, -2)];
+            [selectButton.layer setShadowRadius:4.0];
+            [selectButton.layer setShadowOpacity:0.3];
+            
+            // Set button target and action
+            WindowSelectorDelegate *delegate = [[WindowSelectorDelegate alloc] init];
+            [selectButton setTarget:delegate];
+            [selectButton setAction:@selector(screenSelectButtonClicked:)];
+            
+            // Position button in center of screen
+            NSPoint buttonCenter = NSMakePoint(
+                (screenFrame.size.width - [selectButton frame].size.width) / 2,
+                (screenFrame.size.height - [selectButton frame].size.height) / 2
+            );
+            [selectButton setFrameOrigin:buttonCenter];
+            
+            [overlayView addSubview:selectButton];
+            [overlayWindow orderFront:nil];
+            [overlayWindow makeKeyAndOrderFront:nil];
+            
+            [g_screenOverlayWindows addObject:overlayWindow];
+            [screenInfo release];
+        }
+        
+        g_allScreens = [screenInfoArray retain];
+        [screenInfoArray release];
+        g_isScreenSelecting = true;
+        
+        NSLog(@"🖥️ SCREEN SELECTION: Started with %lu screens", (unsigned long)[screens count]);
+        
+        return true;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Error starting screen selection: %@", exception);
+        cleanupScreenSelector();
+        return false;
+    }
+}
+
+bool stopScreenSelection() {
+    @try {
+        if (!g_isScreenSelecting) return false;
+        
+        cleanupScreenSelector();
+        NSLog(@"🖥️ SCREEN SELECTION: Stopped");
+        return true;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Error stopping screen selection: %@", exception);
+        return false;
+    }
+}
+
+NSDictionary* getSelectedScreenInfo() {
+    if (!g_selectedScreenInfo) return nil;
+    
+    NSDictionary *result = [g_selectedScreenInfo retain];
+    [g_selectedScreenInfo release];
+    g_selectedScreenInfo = nil;
+    
+    return [result autorelease];
+}
+
+bool showScreenRecordingPreview(NSDictionary *screenInfo) {
+    @try {
+        // Clean up any existing preview
+        cleanupRecordingPreview();
+        
+        if (!screenInfo) return false;
+        
+        // For screen recording preview, we show all OTHER screens as black overlay
+        // and keep the selected screen transparent
+        NSArray *screens = [NSScreen screens];
+        if (!screens || [screens count] == 0) return false;
+        
+        int selectedScreenId = [[screenInfo objectForKey:@"id"] intValue];
+        
+        // Create overlay for each screen except the selected one
+        for (NSInteger i = 0; i < [screens count]; i++) {
+            if (i == selectedScreenId) continue; // Skip selected screen
+            
+            NSScreen *screen = [screens objectAtIndex:i];
+            NSRect screenFrame = [screen frame];
+            
+            // Create full-screen black overlay for non-selected screens
+            NSWindow *overlayWindow = [[NSWindow alloc] initWithContentRect:screenFrame
+                                                                  styleMask:NSWindowStyleMaskBorderless
+                                                                    backing:NSBackingStoreBuffered
+                                                                      defer:NO
+                                                                      screen:screen];
+            
+            [overlayWindow setLevel:CGWindowLevelForKey(kCGOverlayWindowLevelKey)];
+            [overlayWindow setOpaque:NO];
+            [overlayWindow setBackgroundColor:[NSColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:0.5]];
+            [overlayWindow setIgnoresMouseEvents:YES];
+            [overlayWindow setAcceptsMouseMovedEvents:NO];
+            [overlayWindow setHasShadow:NO];
+            [overlayWindow setAlphaValue:1.0];
+            [overlayWindow setCollectionBehavior:NSWindowCollectionBehaviorStationary | NSWindowCollectionBehaviorCanJoinAllSpaces];
+            
+            [overlayWindow orderFront:nil];
+            [overlayWindow makeKeyAndOrderFront:nil];
+            
+            // Store for cleanup (reuse recording preview window variable)
+            if (!g_recordingPreviewWindow) {
+                g_recordingPreviewWindow = overlayWindow;
+            }
+        }
+        
+        NSLog(@"🎬 SCREEN RECORDING PREVIEW: Showing overlay for Screen %d", selectedScreenId);
+        
+        return true;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Error showing screen recording preview: %@", exception);
+        return false;
+    }
+}
+
+bool hideScreenRecordingPreview() {
+    return hideRecordingPreview(); // Reuse existing function
+}
+
 // NAPI Function: Start Window Selection
 Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -446,19 +874,14 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         [g_overlayWindow setContentView:g_overlayView];
         
         // Create select button with blue theme
-        g_selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 140, 50)];
+        g_selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 160, 60)];
         [g_selectButton setTitle:@"Select Window"];
         [g_selectButton setButtonType:NSButtonTypeMomentaryPushIn];
         [g_selectButton setBezelStyle:NSBezelStyleRounded];
         [g_selectButton setFont:[NSFont systemFontOfSize:16 weight:NSFontWeightSemibold]];
         
-        // Blue themed button styling
-        [g_selectButton setWantsLayer:YES];
-        [g_selectButton.layer setBackgroundColor:[[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor]];
-        [g_selectButton.layer setCornerRadius:8.0];
-        [g_selectButton.layer setBorderColor:[[NSColor colorWithRed:0.0 green:0.3 blue:0.7 alpha:1.0] CGColor]];
-        [g_selectButton.layer setBorderWidth:2.0];
-        [g_selectButton setContentTintColor:[NSColor whiteColor]];
+        // Remove custom button styling to use system default
+        [g_selectButton setWantsLayer:NO];
         
         // Add shadow for better visibility
         [g_selectButton.layer setShadowColor:[[NSColor blackColor] CGColor]];
@@ -641,6 +1064,193 @@ Napi::Value GetWindowSelectionStatus(const Napi::CallbackInfo& info) {
     return result;
 }
 
+// NAPI Function: Show Recording Preview
+Napi::Value ShowRecordingPreview(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Window info object required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    if (!info[0].IsObject()) {
+        Napi::TypeError::New(env, "Window info must be an object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    @try {
+        Napi::Object windowInfoObj = info[0].As<Napi::Object>();
+        
+        // Convert NAPI object to NSDictionary
+        NSMutableDictionary *windowInfo = [[NSMutableDictionary alloc] init];
+        
+        if (windowInfoObj.Has("id")) {
+            [windowInfo setObject:[NSNumber numberWithInt:windowInfoObj.Get("id").As<Napi::Number>().Int32Value()] forKey:@"id"];
+        }
+        if (windowInfoObj.Has("title")) {
+            [windowInfo setObject:[NSString stringWithUTF8String:windowInfoObj.Get("title").As<Napi::String>().Utf8Value().c_str()] forKey:@"title"];
+        }
+        if (windowInfoObj.Has("appName")) {
+            [windowInfo setObject:[NSString stringWithUTF8String:windowInfoObj.Get("appName").As<Napi::String>().Utf8Value().c_str()] forKey:@"appName"];
+        }
+        if (windowInfoObj.Has("x")) {
+            [windowInfo setObject:[NSNumber numberWithInt:windowInfoObj.Get("x").As<Napi::Number>().Int32Value()] forKey:@"x"];
+        }
+        if (windowInfoObj.Has("y")) {
+            [windowInfo setObject:[NSNumber numberWithInt:windowInfoObj.Get("y").As<Napi::Number>().Int32Value()] forKey:@"y"];
+        }
+        if (windowInfoObj.Has("width")) {
+            [windowInfo setObject:[NSNumber numberWithInt:windowInfoObj.Get("width").As<Napi::Number>().Int32Value()] forKey:@"width"];
+        }
+        if (windowInfoObj.Has("height")) {
+            [windowInfo setObject:[NSNumber numberWithInt:windowInfoObj.Get("height").As<Napi::Number>().Int32Value()] forKey:@"height"];
+        }
+        
+        bool success = showRecordingPreview(windowInfo);
+        [windowInfo release];
+        
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Hide Recording Preview
+Napi::Value HideRecordingPreview(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        bool success = hideRecordingPreview();
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Start Screen Selection
+Napi::Value StartScreenSelection(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        bool success = startScreenSelection();
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Stop Screen Selection
+Napi::Value StopScreenSelection(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        bool success = stopScreenSelection();
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Get Selected Screen Info
+Napi::Value GetSelectedScreenInfo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        NSDictionary *screenInfo = getSelectedScreenInfo();
+        if (!screenInfo) {
+            return env.Null();
+        }
+        
+        Napi::Object result = Napi::Object::New(env);
+        result.Set("id", Napi::Number::New(env, [[screenInfo objectForKey:@"id"] intValue]));
+        result.Set("name", Napi::String::New(env, [[screenInfo objectForKey:@"name"] UTF8String]));
+        result.Set("x", Napi::Number::New(env, [[screenInfo objectForKey:@"x"] intValue]));
+        result.Set("y", Napi::Number::New(env, [[screenInfo objectForKey:@"y"] intValue]));
+        result.Set("width", Napi::Number::New(env, [[screenInfo objectForKey:@"width"] intValue]));
+        result.Set("height", Napi::Number::New(env, [[screenInfo objectForKey:@"height"] intValue]));
+        result.Set("resolution", Napi::String::New(env, [[screenInfo objectForKey:@"resolution"] UTF8String]));
+        result.Set("isPrimary", Napi::Boolean::New(env, [[screenInfo objectForKey:@"isPrimary"] boolValue]));
+        
+        NSLog(@"🖥️ SCREEN SELECTED: %@ (%@)", 
+              [screenInfo objectForKey:@"name"],
+              [screenInfo objectForKey:@"resolution"]);
+        
+        return result;
+        
+    } @catch (NSException *exception) {
+        return env.Null();
+    }
+}
+
+// NAPI Function: Show Screen Recording Preview
+Napi::Value ShowScreenRecordingPreview(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Screen info object required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    if (!info[0].IsObject()) {
+        Napi::TypeError::New(env, "Screen info must be an object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    @try {
+        Napi::Object screenInfoObj = info[0].As<Napi::Object>();
+        
+        // Convert NAPI object to NSDictionary
+        NSMutableDictionary *screenInfo = [[NSMutableDictionary alloc] init];
+        
+        if (screenInfoObj.Has("id")) {
+            [screenInfo setObject:[NSNumber numberWithInt:screenInfoObj.Get("id").As<Napi::Number>().Int32Value()] forKey:@"id"];
+        }
+        if (screenInfoObj.Has("name")) {
+            [screenInfo setObject:[NSString stringWithUTF8String:screenInfoObj.Get("name").As<Napi::String>().Utf8Value().c_str()] forKey:@"name"];
+        }
+        if (screenInfoObj.Has("resolution")) {
+            [screenInfo setObject:[NSString stringWithUTF8String:screenInfoObj.Get("resolution").As<Napi::String>().Utf8Value().c_str()] forKey:@"resolution"];
+        }
+        if (screenInfoObj.Has("x")) {
+            [screenInfo setObject:[NSNumber numberWithInt:screenInfoObj.Get("x").As<Napi::Number>().Int32Value()] forKey:@"x"];
+        }
+        if (screenInfoObj.Has("y")) {
+            [screenInfo setObject:[NSNumber numberWithInt:screenInfoObj.Get("y").As<Napi::Number>().Int32Value()] forKey:@"y"];
+        }
+        if (screenInfoObj.Has("width")) {
+            [screenInfo setObject:[NSNumber numberWithInt:screenInfoObj.Get("width").As<Napi::Number>().Int32Value()] forKey:@"width"];
+        }
+        if (screenInfoObj.Has("height")) {
+            [screenInfo setObject:[NSNumber numberWithInt:screenInfoObj.Get("height").As<Napi::Number>().Int32Value()] forKey:@"height"];
+        }
+        
+        bool success = showScreenRecordingPreview(screenInfo);
+        [screenInfo release];
+        
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Hide Screen Recording Preview
+Napi::Value HideScreenRecordingPreview(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        bool success = hideScreenRecordingPreview();
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
 // Export functions
 Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports) {
     exports.Set("startWindowSelection", Napi::Function::New(env, StartWindowSelection));
@@ -649,6 +1259,13 @@ Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports) {
     exports.Set("getWindowSelectionStatus", Napi::Function::New(env, GetWindowSelectionStatus));
     exports.Set("bringWindowToFront", Napi::Function::New(env, BringWindowToFront));
     exports.Set("setBringToFrontEnabled", Napi::Function::New(env, SetBringToFrontEnabled));
+    exports.Set("showRecordingPreview", Napi::Function::New(env, ShowRecordingPreview));
+    exports.Set("hideRecordingPreview", Napi::Function::New(env, HideRecordingPreview));
+    exports.Set("startScreenSelection", Napi::Function::New(env, StartScreenSelection));
+    exports.Set("stopScreenSelection", Napi::Function::New(env, StopScreenSelection));
+    exports.Set("getSelectedScreenInfo", Napi::Function::New(env, GetSelectedScreenInfo));
+    exports.Set("showScreenRecordingPreview", Napi::Function::New(env, ShowScreenRecordingPreview));
+    exports.Set("hideScreenRecordingPreview", Napi::Function::New(env, HideScreenRecordingPreview));
     
     return exports;
 }

package/window-selector.js

@@ -272,6 +272,146 @@ class WindowSelector extends EventEmitter {
 		this.isSelecting = false;
 	}
 
+	/**
+	 * Seçilen pencere için kayıt önizleme overlay'ini gösterir
+	 * Tüm ekranı siyah yapar, sadece pencere alanını şeffaf bırakır
+	 * @param {Object} windowInfo - Pencere bilgileri
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async showRecordingPreview(windowInfo) {
+		if (!windowInfo) {
+			throw new Error("Window info is required");
+		}
+
+		try {
+			const success = nativeBinding.showRecordingPreview(windowInfo);
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to show recording preview: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Kayıt önizleme overlay'ini gizler
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async hideRecordingPreview() {
+		try {
+			const success = nativeBinding.hideRecordingPreview();
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to hide recording preview: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Ekran seçimi başlatır
+	 * Tüm ekranları overlay ile gösterir ve seçim yapılmasını bekler
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async startScreenSelection() {
+		try {
+			const success = nativeBinding.startScreenSelection();
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to start screen selection: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Ekran seçimini durdurur
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async stopScreenSelection() {
+		try {
+			const success = nativeBinding.stopScreenSelection();
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to stop screen selection: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Seçilen ekran bilgisini döndürür
+	 * @returns {Object|null} Screen info or null
+	 */
+	getSelectedScreen() {
+		try {
+			return nativeBinding.getSelectedScreenInfo();
+		} catch (error) {
+			console.error(`Failed to get selected screen: ${error.message}`);
+			return null;
+		}
+	}
+
+	/**
+	 * Promise tabanlı ekran seçimi
+	 * Kullanıcı bir ekran seçene kadar bekler
+	 * @returns {Promise<Object>} Selected screen info
+	 */
+	async selectScreen() {
+		try {
+			// Start screen selection
+			await this.startScreenSelection();
+			
+			// Poll for selection completion
+			return new Promise((resolve, reject) => {
+				const checkSelection = () => {
+					const selectedScreen = this.getSelectedScreen();
+					if (selectedScreen) {
+						resolve(selectedScreen);
+					} else {
+						// Check again in 100ms
+						setTimeout(checkSelection, 100);
+					}
+				};
+				
+				// Start polling
+				checkSelection();
+				
+				// Timeout after 60 seconds
+				setTimeout(() => {
+					this.stopScreenSelection();
+					reject(new Error('Screen selection timed out'));
+				}, 60000);
+			});
+		} catch (error) {
+			throw new Error(`Failed to select screen: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Seçilen ekran için kayıt önizleme overlay'ini gösterir
+	 * Diğer ekranları siyah yapar, sadece seçili ekranı şeffaf bırakır
+	 * @param {Object} screenInfo - Ekran bilgileri
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async showScreenRecordingPreview(screenInfo) {
+		if (!screenInfo) {
+			throw new Error("Screen info is required");
+		}
+
+		try {
+			const success = nativeBinding.showScreenRecordingPreview(screenInfo);
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to show screen recording preview: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Ekran kayıt önizleme overlay'ini gizler
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async hideScreenRecordingPreview() {
+		try {
+			const success = nativeBinding.hideScreenRecordingPreview();
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to hide screen recording preview: ${error.message}`);
+		}
+	}
+
 	/**
 	 * macOS'ta pencere seçim izinlerini kontrol eder
 	 */