node-mac-recorder 2.20.7 → 2.20.9

package/.claude/settings.local.json

@@ -2,7 +2,8 @@
   "permissions": {
     "allow": [
       "Bash(node-gyp:*)",
-      "Bash(node:*)"
+      "Bash(node:*)",
+      "Bash(timeout:*)"
     ],
     "deny": [],
     "ask": []

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -5,6 +5,7 @@
 #import <QuartzCore/QuartzCore.h>
 #import <AppKit/AppKit.h>
 #include <string>
+#import "logging.h"
 
 static AVAssetWriter *g_avWriter = nil;
 static AVAssetWriterInput *g_avVideoInput = nil;
@@ -32,7 +33,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
     }
     
     @try {
-        NSLog(@"🎬 AVFoundation: Starting recording initialization");
+        MRLog(@"🎬 AVFoundation: Starting recording initialization");
         
         // Create output URL
         NSString *outputPathStr = [NSString stringWithUTF8String:outputPath.c_str()];
@@ -42,7 +43,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         NSError *removeError = nil;
         [[NSFileManager defaultManager] removeItemAtURL:outputURL error:&removeError];
         if (removeError && removeError.code != NSFileNoSuchFileError) {
-            NSLog(@"⚠️ AVFoundation: Warning removing existing file: %@", removeError);
+            MRLog(@"⚠️ AVFoundation: Warning removing existing file: %@", removeError);
         }
         
         // Create asset writer
@@ -85,21 +86,21 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             recordingSize = actualImageSize;
         }
         
-        NSLog(@"🎯 CRITICAL: Logical %.0fx%.0f → Actual image %.0fx%.0f", 
+        MRLog(@"🎯 CRITICAL: Logical %.0fx%.0f → Actual image %.0fx%.0f", 
               logicalSize.width, logicalSize.height, actualImageSize.width, actualImageSize.height);
         
-        NSLog(@"🖥️ Display bounds (logical): %.0fx%.0f", logicalSize.width, logicalSize.height);
-        NSLog(@"🖥️ Display pixels (physical): %.0fx%.0f", physicalSize.width, physicalSize.height);
+        MRLog(@"🖥️ Display bounds (logical): %.0fx%.0f", logicalSize.width, logicalSize.height);
+        MRLog(@"🖥️ Display pixels (physical): %.0fx%.0f", physicalSize.width, physicalSize.height);
         
         if (scaleFactor > 1.5) {
-            NSLog(@"🔍 Scale factor: %.1fx → Retina display detected (macOS 14/13 scaling fix applied)", scaleFactor);
+            MRLog(@"🔍 Scale factor: %.1fx → Retina display detected (macOS 14/13 scaling fix applied)", scaleFactor);
         } else if (scaleFactor > 1.1) {
-            NSLog(@"🔍 Scale factor: %.1fx → Non-standard scaling detected", scaleFactor);
+            MRLog(@"🔍 Scale factor: %.1fx → Non-standard scaling detected", scaleFactor);
         } else {
-            NSLog(@"🔍 Scale factor: %.1fx → Standard display", scaleFactor);
+            MRLog(@"🔍 Scale factor: %.1fx → Standard display", scaleFactor);
         }
         
-        NSLog(@"🎯 Recording size: %.0fx%.0f (using actual physical dimensions for Retina fix)", recordingSize.width, recordingSize.height);
+        MRLog(@"🎯 Recording size: %.0fx%.0f (using actual physical dimensions for Retina fix)", recordingSize.width, recordingSize.height);
         
         // Video settings with macOS compatibility
         NSString *codecKey;
@@ -142,7 +143,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             (NSString*)kCVPixelBufferCGBitmapContextCompatibilityKey: @YES
         };
         
-        NSLog(@"🔧 Using pixel format: %u", pixelFormat);
+        MRLog(@"🔧 Using pixel format: %u", pixelFormat);
         
         g_avPixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:g_avVideoInput sourcePixelBufferAttributes:pixelBufferAttributes];
         
@@ -253,11 +254,11 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                         size_t imageWidth = CGImageGetWidth(screenImage);
                         size_t imageHeight = CGImageGetHeight(screenImage);
                         
-                        NSLog(@"🔍 Debug: Buffer %zux%zu, Image %zux%zu", bufferWidth, bufferHeight, imageWidth, imageHeight);
+                        MRLog(@"🔍 Debug: Buffer %zux%zu, Image %zux%zu", bufferWidth, bufferHeight, imageWidth, imageHeight);
                         
                         if (bufferWidth != imageWidth || bufferHeight != imageHeight) {
-                            NSLog(@"🔧 EXPECTED SIZE DIFFERENCE: Buffer %zux%zu (logical) vs Image %zux%zu (physical)", bufferWidth, bufferHeight, imageWidth, imageHeight);
-                            NSLog(@"   This is normal on Retina displays - scaling handled correctly now");
+                            MRLog(@"🔧 EXPECTED SIZE DIFFERENCE: Buffer %zux%zu (logical) vs Image %zux%zu (physical)", bufferWidth, bufferHeight, imageWidth, imageHeight);
+                            MRLog(@"   This is normal on Retina displays - scaling handled correctly now");
                         }
                         
                         CVPixelBufferLockBaseAddress(pixelBuffer, 0);
@@ -332,7 +333,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         dispatch_resume(g_avTimer);
         g_avIsRecording = true;
         
-        NSLog(@"🎥 AVFoundation recording started: %dx%d @ 10fps", 
+        MRLog(@"🎥 AVFoundation recording started: %dx%d @ 10fps", 
               (int)recordingSize.width, (int)recordingSize.height);
         
         return true;
@@ -365,7 +366,7 @@ extern "C" bool stopAVFoundationRecording() {
             });
             
             g_avTimer = nil;
-            NSLog(@"✅ AVFoundation timer stopped safely");
+            MRLog(@"✅ AVFoundation timer stopped safely");
         }
         
         // Finish writing with null checks
@@ -391,7 +392,7 @@ extern "C" bool stopAVFoundationRecording() {
         g_avPixelBufferAdaptor = nil;
         g_avFrameNumber = 0;
         
-        NSLog(@"✅ AVFoundation recording stopped");
+        MRLog(@"✅ AVFoundation recording stopped");
         return true;
         
     } @catch (NSException *exception) {
@@ -402,4 +403,4 @@ extern "C" bool stopAVFoundationRecording() {
 
 extern "C" bool isAVFoundationRecording() {
     return g_avIsRecording;
-}
+}

package/src/cursor_tracker.mm

@@ -6,6 +6,7 @@
 #import <Carbon/Carbon.h>
 #import <Accessibility/Accessibility.h>
 #import <dispatch/dispatch.h>
+#import "logging.h"
 
 #ifndef kAXHitTestParameterizedAttribute
 #define kAXHitTestParameterizedAttribute CFSTR("AXHitTest")
@@ -391,56 +392,100 @@ static NSString* cursorTypeFromCursorName(NSString *value) {
 
     NSString *normalized = [[value stringByReplacingOccurrencesOfString:@"_" withString:@"-"] lowercaseString];
 
-    if ([normalized containsString:@"arrow"]) {
+    // Arrow cursor patterns
+    if ([normalized containsString:@"arrow"] || [normalized containsString:@"default"]) {
         return @"default";
     }
+
+    // Text cursor patterns
     if ([normalized containsString:@"ibeam"] ||
         [normalized containsString:@"insertion"] ||
-        [normalized containsString:@"text"]) {
+        [normalized containsString:@"text"] ||
+        [normalized containsString:@"edit"]) {
         return @"text";
     }
-    if ([normalized containsString:@"openhand"]) {
+
+    // Hand cursors
+    if ([normalized containsString:@"openhand"] || [normalized containsString:@"open-hand"]) {
         return @"grab";
     }
-    if ([normalized containsString:@"closedhand"]) {
+    if ([normalized containsString:@"closedhand"] || [normalized containsString:@"closed-hand"]) {
         return @"grabbing";
     }
+
+    // Pointer cursor patterns
     if ([normalized containsString:@"pointing"] ||
-        ([normalized containsString:@"hand"] && ![normalized containsString:@"closed"])) {
+        [normalized containsString:@"pointinghand"] ||
+        ([normalized containsString:@"hand"] && ![normalized containsString:@"closed"] && ![normalized containsString:@"open"]) ||
+        [normalized containsString:@"link"] ||
+        [normalized containsString:@"button"]) {
         return @"pointer";
     }
-    if ([normalized containsString:@"crosshair"]) {
+
+    // Crosshair patterns
+    if ([normalized containsString:@"crosshair"] || [normalized containsString:@"cross-hair"]) {
         return @"crosshair";
     }
+
+    // Not allowed patterns
     if ([normalized containsString:@"not-allowed"] ||
         [normalized containsString:@"notallowed"] ||
-        [normalized containsString:@"forbidden"]) {
+        [normalized containsString:@"forbidden"] ||
+        [normalized containsString:@"operation-not-allowed"]) {
         return @"not-allowed";
     }
-    if ([normalized containsString:@"dragcopy"] || [normalized containsString:@"copy"]) {
+
+    // Copy cursor patterns
+    if ([normalized containsString:@"dragcopy"] ||
+        [normalized containsString:@"drag-copy"] ||
+        [normalized containsString:@"copy"]) {
         return @"copy";
     }
-    if ([normalized containsString:@"draglink"] || [normalized containsString:@"alias"]) {
+
+    // Alias cursor patterns
+    if ([normalized containsString:@"draglink"] ||
+        [normalized containsString:@"drag-link"] ||
+        [normalized containsString:@"alias"]) {
         return @"alias";
     }
-    if ([normalized containsString:@"context"] && [normalized containsString:@"menu"]) {
+
+    // Context menu patterns
+    if (([normalized containsString:@"context"] && [normalized containsString:@"menu"]) ||
+        [normalized containsString:@"contextual-menu"]) {
         return @"context-menu";
     }
+
+    // Zoom patterns
     if ([normalized containsString:@"zoom"]) {
         if ([normalized containsString:@"out"]) {
             return @"zoom-out";
         }
         return @"zoom-in";
     }
+
+    // Resize cursor patterns - more comprehensive
     if ([normalized containsString:@"resize"] || [normalized containsString:@"size"]) {
-        BOOL diagonalUp = [normalized containsString:@"diagonalup"] || [normalized containsString:@"nesw"];
-        BOOL diagonalDown = [normalized containsString:@"diagonaldown"] || [normalized containsString:@"nwse"];
+        // Diagonal resize cursors
+        BOOL diagonalUp = [normalized containsString:@"diagonalup"] ||
+                          [normalized containsString:@"diagonal-up"] ||
+                          [normalized containsString:@"nesw"];
+        BOOL diagonalDown = [normalized containsString:@"diagonaldown"] ||
+                            [normalized containsString:@"diagonal-down"] ||
+                            [normalized containsString:@"nwse"];
+
+        // Horizontal and vertical resize
         BOOL horizontal = [normalized containsString:@"leftright"] ||
+                          [normalized containsString:@"left-right"] ||
                           [normalized containsString:@"horizontal"] ||
-                          ([normalized containsString:@"left"] && [normalized containsString:@"right"]);
+                          ([normalized containsString:@"left"] && [normalized containsString:@"right"]) ||
+                          [normalized containsString:@"col"] ||
+                          [normalized containsString:@"column"];
+
         BOOL vertical = [normalized containsString:@"updown"] ||
+                        [normalized containsString:@"up-down"] ||
                         [normalized containsString:@"vertical"] ||
-                        ([normalized containsString:@"up"] && [normalized containsString:@"down"]);
+                        ([normalized containsString:@"up"] && [normalized containsString:@"down"]) ||
+                        [normalized containsString:@"row"];
 
         if (diagonalUp) {
             return @"nesw-resize";
@@ -454,6 +499,22 @@ static NSString* cursorTypeFromCursorName(NSString *value) {
         if (horizontal) {
             return @"col-resize";
         }
+
+        // Generic resize fallback
+        return @"default"; // or could be a generic resize
+    }
+
+    // Additional specific patterns
+    if ([normalized containsString:@"wait"] || [normalized containsString:@"busy"]) {
+        return @"wait";
+    }
+
+    if ([normalized containsString:@"help"] || [normalized containsString:@"question"]) {
+        return @"help";
+    }
+
+    if ([normalized containsString:@"progress"]) {
+        return @"progress";
     }
 
     return nil;
@@ -461,9 +522,10 @@ static NSString* cursorTypeFromCursorName(NSString *value) {
 
 static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
     if (!cursor) {
-        return nil;
+        return @"default";
     }
 
+    // Standard macOS cursors
     if (cursor == [NSCursor arrowCursor]) {
         return @"default";
     }
@@ -498,34 +560,66 @@ static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
     if (cursor == [NSCursor contextualMenuCursor]) {
         return @"context-menu";
     }
-    if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)] &&
-        (cursor == [NSCursor resizeLeftRightCursor] ||
-         cursor == [NSCursor resizeLeftCursor] ||
-         cursor == [NSCursor resizeRightCursor])) {
-        return @"col-resize";
+
+    // Resize cursors - improved detection
+    if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)]) {
+        if (cursor == [NSCursor resizeLeftRightCursor]) {
+            return @"col-resize";
+        }
     }
-    if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)] &&
-        (cursor == [NSCursor resizeUpDownCursor] ||
-         cursor == [NSCursor resizeUpCursor] ||
-         cursor == [NSCursor resizeDownCursor])) {
-        return @"ns-resize";
+    if ([NSCursor respondsToSelector:@selector(resizeLeftCursor)]) {
+        if (cursor == [NSCursor resizeLeftCursor]) {
+            return @"col-resize";
+        }
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeRightCursor)]) {
+        if (cursor == [NSCursor resizeRightCursor]) {
+            return @"col-resize";
+        }
     }
+    if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)]) {
+        if (cursor == [NSCursor resizeUpDownCursor]) {
+            return @"ns-resize";
+        }
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeUpCursor)]) {
+        if (cursor == [NSCursor resizeUpCursor]) {
+            return @"ns-resize";
+        }
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeDownCursor)]) {
+        if (cursor == [NSCursor resizeDownCursor]) {
+            return @"ns-resize";
+        }
+    }
+
     if ([NSCursor respondsToSelector:@selector(disappearingItemCursor)] &&
         cursor == [NSCursor disappearingItemCursor]) {
         return @"default";
     }
 
-    NSString *derived = cursorTypeFromCursorName(NSStringFromClass([cursor class]));
+    // Try to get class name and description for debugging
+    NSString *className = NSStringFromClass([cursor class]);
+    NSString *description = [cursor description];
+
+    MRLog(@"🔍 Unknown cursor class: %@, description: %@", className ?: @"nil", description ?: @"nil");
+
+    // Try name-based detection
+    NSString *derived = cursorTypeFromCursorName(className);
     if (derived) {
+        MRLog(@"🎯 Cursor type from class name: %@", derived);
         return derived;
     }
 
-    derived = cursorTypeFromCursorName([cursor description]);
+    derived = cursorTypeFromCursorName(description);
     if (derived) {
+        MRLog(@"🎯 Cursor type from description: %@", derived);
         return derived;
     }
 
-    return nil;
+    // Default fallback
+    MRLog(@"⚠️ Unknown cursor type, defaulting to 'default'");
+    return @"default";
 }
 
 static NSString* detectSystemCursorType(void) {
@@ -533,21 +627,59 @@ static NSString* detectSystemCursorType(void) {
 
     void (^fetchCursorBlock)(void) = ^{
         NSCursor *currentCursor = nil;
+
+        // Try different methods to get current cursor
         if ([NSCursor respondsToSelector:@selector(currentSystemCursor)]) {
             currentCursor = [NSCursor currentSystemCursor];
+            NSLog(@"🖱️ currentSystemCursor: %@", currentCursor ?: @"nil");
         }
+
         if (!currentCursor) {
             currentCursor = [NSCursor currentCursor];
+            NSLog(@"🖱️ currentCursor: %@", currentCursor ?: @"nil");
         }
 
-        NSString *derivedType = cursorTypeFromNSCursor(currentCursor);
-        if (derivedType) {
-            cursorType = derivedType;
-        } else if (currentCursor) {
+        if (currentCursor) {
+            NSString *className = NSStringFromClass([currentCursor class]);
+            NSString *description = [currentCursor description];
+            NSLog(@"🖱️ Cursor class: %@, description: %@", className ?: @"nil", description ?: @"nil");
+
+            // Try to identify cursor by hotspot and size (more reliable than pointer equality)
+            NSPoint hotspot = [currentCursor hotSpot];
+            NSSize cursorSize = [[currentCursor image] size];
+
+            NSLog(@"🎯 Cursor hotspot: (%.1f, %.1f), size: %.1fx%.1f",
+                  hotspot.x, hotspot.y, cursorSize.width, cursorSize.height);
+
+            // Common cursor patterns by hotspot (adjusted for modern macOS cursor sizes)
+            if ((hotspot.x >= 0.0 && hotspot.x <= 3.0) && (hotspot.y >= 0.0 && hotspot.y <= 3.0)) {
+                // Arrow cursor typically has hotspot at top-left corner
+                cursorType = @"default";
+                NSLog(@"🎯 ARROW CURSOR (by hotspot) -> default");
+            } else if ((hotspot.x >= 12.0 && hotspot.x <= 16.0) && (hotspot.y >= 6.0 && hotspot.y <= 10.0)) {
+                // I-beam cursor typically has hotspot around middle
+                cursorType = @"text";
+                NSLog(@"🎯 IBEAM CURSOR (by hotspot) -> text");
+            } else if ((hotspot.x >= 5.0 && hotspot.x <= 10.0) && (hotspot.y >= 0.0 && hotspot.y <= 4.0)) {
+                // Pointing hand cursor typically has hotspot at finger tip
+                cursorType = @"pointer";
+                NSLog(@"🎯 POINTING HAND CURSOR (by hotspot) -> pointer");
+            } else {
+                // Fallback to more detailed analysis
+                NSString *derivedType = cursorTypeFromNSCursor(currentCursor);
+                if (derivedType && ![derivedType isEqualToString:@"default"]) {
+                    cursorType = derivedType;
+                    NSLog(@"🎯 SYSTEM CURSOR TYPE (derived): %@", cursorType);
+                } else {
+                    // Use accessibility detection if system cursor is generic
+                    cursorType = @"default";
+                    NSLog(@"🎯 SYSTEM CURSOR TYPE -> default (will try AX)");
+                }
+            }
+        } else {
+            NSLog(@"🖱️ No current cursor found");
             cursorType = @"default";
         }
-
-        NSLog(@"🎯 SYSTEM CURSOR TYPE: %@", cursorType ? cursorType : @"(nil)");
     };
 
     if ([NSThread isMainThread]) {
@@ -563,7 +695,7 @@ NSString* getCursorType() {
     @autoreleasepool {
         g_cursorTypeCounter++;
 
-        // Hybrid: AX (strict) first, then system cursor fallback.
+        // Get cursor position first
         BOOL hasCursorPosition = NO;
         CGPoint cursorPos = CGPointZero;
 
@@ -588,22 +720,32 @@ NSString* getCursorType() {
             }
         }
 
+        // Try multiple detection methods
+        NSString *systemCursorType = detectSystemCursorType();
         NSString *axCursorType = nil;
+
         if (hasCursorPosition) {
             axCursorType = detectCursorTypeUsingAccessibility(cursorPos);
         }
 
-        NSString *systemCursorType = detectSystemCursorType();
+        NSString *finalType = @"default";
 
-        NSString *finalType = nil;
-        if (axCursorType && ![axCursorType isEqualToString:@"default"]) {
-            finalType = axCursorType;
-        } else if (systemCursorType && [systemCursorType length] > 0) {
+        // System cursor has priority since it's more accurate for visual state
+        NSLog(@"🎯 CURSOR DECISION: system='%@', ax='%@'", systemCursorType ?: @"nil", axCursorType ?: @"nil");
+
+        // Use system cursor if available (it's more accurate for visual appearance)
+        if (systemCursorType && [systemCursorType length] > 0) {
             finalType = systemCursorType;
-        } else if (axCursorType && [axCursorType length] > 0) {
+            NSLog(@"🎯 Using SYSTEM cursor: %@", finalType);
+        }
+        // Fallback to AX cursor if system cursor is not available
+        else if (axCursorType && [axCursorType length] > 0) {
             finalType = axCursorType;
-        } else {
-            finalType = @"default";
+            NSLog(@"🎯 Using AX cursor (fallback): %@", finalType);
+        }
+        // Final fallback
+        else {
+            NSLog(@"🎯 Fallback to default cursor");
         }
 
         NSLog(@"🎯 FINAL CURSOR TYPE: %@", finalType);

package/src/electron_safe/cursor_tracker_electron.mm

@@ -1,6 +1,7 @@
 #import <napi.h>
 #import <CoreGraphics/CoreGraphics.h>
 #import <AppKit/AppKit.h>
+#import "../logging.h"
 
 // Thread-safe cursor tracking for Electron
 static dispatch_queue_t g_cursorQueue = nil;
@@ -12,47 +13,65 @@ static void initializeCursorQueue() {
     });
 }
 
+static NSString* MapCursorToType(NSCursor *cursor) {
+    if (!cursor) return @"default";
+
+    if (cursor == [NSCursor arrowCursor]) return @"default";
+    if (cursor == [NSCursor IBeamCursor]) return @"text";
+    if ([NSCursor respondsToSelector:@selector(IBeamCursorForVerticalLayout)] &&
+        cursor == [NSCursor IBeamCursorForVerticalLayout]) return @"text";
+    if (cursor == [NSCursor pointingHandCursor]) return @"pointer";
+    if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)]) {
+        if (cursor == [NSCursor resizeLeftRightCursor] ||
+            [NSCursor instancesRespondToSelector:@selector(resizeLeftCursor)] && (cursor == [NSCursor resizeLeftCursor]) ||
+            [NSCursor instancesRespondToSelector:@selector(resizeRightCursor)] && (cursor == [NSCursor resizeRightCursor])) {
+            return @"col-resize";
+        }
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)]) {
+        if (cursor == [NSCursor resizeUpDownCursor] ||
+            [NSCursor instancesRespondToSelector:@selector(resizeUpCursor)] && (cursor == [NSCursor resizeUpCursor]) ||
+            [NSCursor instancesRespondToSelector:@selector(resizeDownCursor)] && (cursor == [NSCursor resizeDownCursor])) {
+            return @"ns-resize";
+        }
+    }
+    if ([NSCursor respondsToSelector:@selector(openHandCursor)] && cursor == [NSCursor openHandCursor]) return @"grab";
+    if ([NSCursor respondsToSelector:@selector(closedHandCursor)] && cursor == [NSCursor closedHandCursor]) return @"grabbing";
+    if ([NSCursor respondsToSelector:@selector(crosshairCursor)] && cursor == [NSCursor crosshairCursor]) return @"crosshair";
+    if ([NSCursor respondsToSelector:@selector(operationNotAllowedCursor)] && cursor == [NSCursor operationNotAllowedCursor]) return @"not-allowed";
+    if ([NSCursor respondsToSelector:@selector(dragCopyCursor)] && cursor == [NSCursor dragCopyCursor]) return @"copy";
+    if ([NSCursor respondsToSelector:@selector(dragLinkCursor)] && cursor == [NSCursor dragLinkCursor]) return @"alias";
+    if ([NSCursor respondsToSelector:@selector(contextualMenuCursor)] && cursor == [NSCursor contextualMenuCursor]) return @"context-menu";
+
+    return @"default";
+}
+
 // NAPI Function: Get Cursor Position (Electron-safe)
 Napi::Value GetCursorPositionElectronSafe(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     @try {
         initializeCursorQueue();
-        
         __block CGPoint mouseLocation = CGPointZero;
-        __block NSString *cursorType = @"arrow";
-        
+        __block NSString *cursorType = @"default";
+
         dispatch_sync(g_cursorQueue, ^{
             @try {
-                // Get mouse location
-                mouseLocation = [NSEvent mouseLocation];
-                
-                // Convert to screen coordinates (flip Y)
-                NSArray *screens = [NSScreen screens];
-                if (screens.count > 0) {
-                    NSScreen *mainScreen = screens[0];
-                    CGFloat screenHeight = mainScreen.frame.size.height;
-                    mouseLocation.y = screenHeight - mouseLocation.y;
+                // Use CGEventGetLocation to match global logical coordinates used elsewhere
+                CGEventRef event = CGEventCreate(NULL);
+                mouseLocation = CGEventGetLocation(event);
+                if (event) CFRelease(event);
+
+                // Prefer currentSystemCursor when available for accurate system-wide state
+                NSCursor *cursor = nil;
+                if ([NSCursor respondsToSelector:@selector(currentSystemCursor)]) {
+                    cursor = [NSCursor performSelector:@selector(currentSystemCursor)];
                 }
-                
-                // Get cursor type safely
-                NSCursor *currentCursor = [NSCursor currentCursor];
-                if (currentCursor) {
-                    if (currentCursor == [NSCursor arrowCursor]) {
-                        cursorType = @"arrow";
-                    } else if (currentCursor == [NSCursor IBeamCursor]) {
-                        cursorType = @"ibeam";
-                    } else if (currentCursor == [NSCursor pointingHandCursor]) {
-                        cursorType = @"hand";
-                    } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
-                        cursorType = @"resize-horizontal";
-                    } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
-                        cursorType = @"resize-vertical";
-                    } else {
-                        cursorType = @"default";
-                    }
+                if (!cursor) {
+                    cursor = [NSCursor currentCursor];
                 }
-                
+                cursorType = MapCursorToType(cursor);
+                MRLog(@"Electron-safe cursor: %@ at (%.0f,%.0f)", cursorType, mouseLocation.x, mouseLocation.y);
             } @catch (NSException *e) {
                 NSLog(@"❌ Exception getting cursor position: %@", e.reason);
             }
@@ -80,7 +99,7 @@ Napi::Object InitCursorTrackerElectron(Napi::Env env, Napi::Object exports) {
         
         exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPositionElectronSafe));
         
-        NSLog(@"✅ Electron-safe cursor tracker initialized");
+        MRLog(@"✅ Electron-safe cursor tracker initialized");
         return exports;
         
     } @catch (NSException *e) {

package/src/logging.h

@@ -0,0 +1,17 @@
+// Lightweight runtime-controlled logging helpers
+#import <Foundation/Foundation.h>
+
+static inline BOOL MRShouldVerboseLog(void) {
+    static dispatch_once_t onceToken;
+    static BOOL enabled = NO;
+    dispatch_once(&onceToken, ^{
+        const char *env = getenv("MAC_RECORDER_DEBUG");
+        if (env && (*env == '1' || *env == 't' || *env == 'T' || *env == 'y' || *env == 'Y')) {
+            enabled = YES;
+        }
+    });
+    return enabled;
+}
+
+#define MRLog(fmt, ...) do { if (MRShouldVerboseLog()) { NSLog((fmt), ##__VA_ARGS__); } } while(0)
+

package/src/mac_recorder.mm

@@ -4,6 +4,7 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <ImageIO/ImageIO.h>
 #import <CoreAudio/CoreAudio.h>
+#import "logging.h"
 
 // Import screen capture (ScreenCaptureKit only)
 #import "screen_capture_kit.h"
@@ -70,11 +71,11 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     // IMPORTANT: Clean up any stale recording state before starting
     // This fixes the issue where macOS 14/13 users get "recording already in progress"
-    NSLog(@"🧹 Cleaning up any previous recording state...");
+    MRLog(@"🧹 Cleaning up any previous recording state...");
     cleanupRecording();
     
     if (g_isRecording) {
-        NSLog(@"⚠️ Still recording after cleanup - forcing stop");
+        MRLog(@"⚠️ Still recording after cleanup - forcing stop");
         return Napi::Boolean::New(env, false);
     }
     
@@ -168,13 +169,13 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         // Window ID support 
         if (options.Has("windowId") && !options.Get("windowId").IsNull()) {
             windowID = options.Get("windowId").As<Napi::Number>().Uint32Value();
-            NSLog(@"🪟 Window ID specified: %u", windowID);
+            MRLog(@"🪟 Window ID specified: %u", windowID);
         }
     }
     
     @try {
         // Smart Recording Selection: ScreenCaptureKit vs Alternative
-        NSLog(@"🎯 Smart Recording Engine Selection");
+        MRLog(@"🎯 Smart Recording Engine Selection");
         
         // Electron environment detection (removed disable logic)
         BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
@@ -186,8 +187,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                           [NSBundle.mainBundle.bundlePath containsString:@"Electron"]);
         
         if (isElectron) {
-            NSLog(@"⚡ Electron environment detected - continuing with ScreenCaptureKit");
-            NSLog(@"⚠️ Warning: ScreenCaptureKit in Electron may require additional stability measures");
+            MRLog(@"⚡ Electron environment detected - continuing with ScreenCaptureKit");
+            MRLog(@"⚠️ Warning: ScreenCaptureKit in Electron may require additional stability measures");
         }
         
         // Check macOS version for ScreenCaptureKit compatibility
@@ -196,13 +197,13 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         BOOL isM14Plus = (osVersion.majorVersion >= 14);
         BOOL isM13Plus = (osVersion.majorVersion >= 13);
         
-        NSLog(@"🖥️ macOS Version: %ld.%ld.%ld", 
+        MRLog(@"🖥️ macOS Version: %ld.%ld.%ld", 
               (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
         
         // Force AVFoundation for debugging/testing
         BOOL forceAVFoundation = (getenv("FORCE_AVFOUNDATION") != NULL);
         if (forceAVFoundation) {
-            NSLog(@"🔧 FORCE_AVFOUNDATION environment variable detected - skipping ScreenCaptureKit");
+            MRLog(@"🔧 FORCE_AVFOUNDATION environment variable detected - skipping ScreenCaptureKit");
         }
         
         // Electron-first priority: This application is built for Electron.js
@@ -210,16 +211,16 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         // macOS 14/13 → AVFoundation (including Electron)
         if (isM15Plus && !forceAVFoundation) {
             if (isElectron) {
-                NSLog(@"⚡ ELECTRON PRIORITY: macOS 15+ Electron → ScreenCaptureKit with full support");
+                MRLog(@"⚡ ELECTRON PRIORITY: macOS 15+ Electron → ScreenCaptureKit with full support");
             } else {
-                NSLog(@"✅ macOS 15+ Node.js → ScreenCaptureKit available with full compatibility");
+                MRLog(@"✅ macOS 15+ Node.js → ScreenCaptureKit available with full compatibility");
             }
             
             // Try ScreenCaptureKit with extensive safety measures
             @try {
                 if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
-                    NSLog(@"✅ ScreenCaptureKit availability check passed");
-                    NSLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
+                    MRLog(@"✅ ScreenCaptureKit availability check passed");
+                    MRLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
                     
                     // Create configuration for ScreenCaptureKit
                 NSMutableDictionary *sckConfig = [NSMutableDictionary dictionary];
@@ -251,7 +252,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                                   dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                         if (!sckStarted && !g_isRecording) {
                             sckTimedOut = YES;
-                            NSLog(@"⏰ ScreenCaptureKit initialization timeout (3s)");
+                            MRLog(@"⏰ ScreenCaptureKit initialization timeout (3s)");
                         }
                     });
                     
@@ -263,8 +264,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                             
                             // ScreenCaptureKit başlatma başarılı - validation yapmıyoruz
                             sckStarted = YES;
-                            NSLog(@"🎬 RECORDING METHOD: ScreenCaptureKit");
-                            NSLog(@"✅ ScreenCaptureKit recording started successfully");
+                            MRLog(@"🎬 RECORDING METHOD: ScreenCaptureKit");
+                            MRLog(@"✅ ScreenCaptureKit recording started successfully");
                             g_isRecording = true;
                             return Napi::Boolean::New(env, true);
                         } else {
@@ -274,7 +275,6 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                     } @catch (NSException *sckException) {
                         NSLog(@"❌ Exception during ScreenCaptureKit startup: %@", sckException.reason);
                     }
-                    
                     NSLog(@"❌ ScreenCaptureKit failed or unsafe - will fallback to AVFoundation");
                     
                 } else {
@@ -285,22 +285,22 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             }
             
             // If we reach here, ScreenCaptureKit failed, so fall through to AVFoundation
-            NSLog(@"⏭️ ScreenCaptureKit failed - falling back to AVFoundation");
+            MRLog(@"⏭️ ScreenCaptureKit failed - falling back to AVFoundation");
         } else {
             // macOS 14/13 or forced AVFoundation → ALWAYS use AVFoundation (Electron supported!)
             if (isElectron) {
                 if (isM14Plus) {
-                    NSLog(@"⚡ ELECTRON PRIORITY: macOS 14/13 Electron → AVFoundation with full support");
+                    MRLog(@"⚡ ELECTRON PRIORITY: macOS 14/13 Electron → AVFoundation with full support");
                 } else if (isM13Plus) {
-                    NSLog(@"⚡ ELECTRON PRIORITY: macOS 13 Electron → AVFoundation with limited features");
+                    MRLog(@"⚡ ELECTRON PRIORITY: macOS 13 Electron → AVFoundation with limited features");
                 }
             } else {
                 if (isM15Plus) {
-                    NSLog(@"🎯 macOS 15+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
+                    MRLog(@"🎯 macOS 15+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
                 } else if (isM14Plus) {
-                    NSLog(@"🎯 macOS 14 Node.js → using AVFoundation (primary method)");
+                    MRLog(@"🎯 macOS 14 Node.js → using AVFoundation (primary method)");
                 } else if (isM13Plus) {
-                    NSLog(@"🎯 macOS 13 Node.js → using AVFoundation (limited features)");  
+                    MRLog(@"🎯 macOS 13 Node.js → using AVFoundation (limited features)");  
                 }
             }
             
@@ -310,11 +310,11 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             }
             
             // DIRECT AVFoundation for all environments (Node.js + Electron)
-            NSLog(@"⏭️ Using AVFoundation directly - supports both Node.js and Electron");
+            MRLog(@"⏭️ Using AVFoundation directly - supports both Node.js and Electron");
         }
         
         // AVFoundation recording (either fallback from ScreenCaptureKit or direct)
-        NSLog(@"🎥 Starting AVFoundation recording...");
+        MRLog(@"🎥 Starting AVFoundation recording...");
         
         @try {
             // Import AVFoundation recording functions (if available)
@@ -331,8 +331,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                                                       captureCursor, includeMicrophone, includeSystemAudio, audioDeviceId);
             
             if (avResult) {
-                NSLog(@"🎥 RECORDING METHOD: AVFoundation");
-                NSLog(@"✅ AVFoundation recording started successfully");
+                MRLog(@"🎥 RECORDING METHOD: AVFoundation");
+                MRLog(@"✅ AVFoundation recording started successfully");
                 g_isRecording = true;
                 return Napi::Boolean::New(env, true);
             } else {
@@ -358,12 +358,12 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
 Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    NSLog(@"📞 StopRecording native method called");
+    MRLog(@"📞 StopRecording native method called");
     
     // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
         if ([ScreenCaptureKitRecorder isRecording]) {
-            NSLog(@"🛑 Stopping ScreenCaptureKit recording");
+            MRLog(@"🛑 Stopping ScreenCaptureKit recording");
             [ScreenCaptureKitRecorder stopRecording];
             g_isRecording = false;
             return Napi::Boolean::New(env, true);
@@ -376,7 +376,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     
     @try {
         if (isAVFoundationRecording()) {
-            NSLog(@"🛑 Stopping AVFoundation recording");
+            MRLog(@"🛑 Stopping AVFoundation recording");
             if (stopAVFoundationRecording()) {
                 g_isRecording = false;
                 return Napi::Boolean::New(env, true);
@@ -392,7 +392,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
         return Napi::Boolean::New(env, false);
     }
     
-    NSLog(@"⚠️ No active recording found to stop");
+    MRLog(@"⚠️ No active recording found to stop");
     g_isRecording = false;
     return Napi::Boolean::New(env, true);
 }
@@ -997,4 +997,4 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     return exports;
 }
 
-NODE_API_MODULE(mac_recorder, Init) 
+NODE_API_MODULE(mac_recorder, Init) 

package/src/screen_capture_kit.mm

@@ -1,4 +1,5 @@
 #import "screen_capture_kit.h"
+#import "logging.h"
 
 // Pure ScreenCaptureKit implementation - NO AVFoundation
 static SCStream * API_AVAILABLE(macos(12.3)) g_stream = nil;
@@ -13,11 +14,11 @@ static NSString *g_outputPath = nil;
 
 @implementation PureScreenCaptureDelegate
 - (void)stream:(SCStream * API_AVAILABLE(macos(12.3)))stream didStopWithError:(NSError *)error API_AVAILABLE(macos(12.3)) {
-    NSLog(@"🛑 Pure ScreenCapture stream stopped");
+    MRLog(@"🛑 Pure ScreenCapture stream stopped");
     
     // Prevent recursive calls during cleanup
     if (g_isCleaningUp) {
-        NSLog(@"⚠️ Already cleaning up, ignoring delegate callback");
+        MRLog(@"⚠️ Already cleaning up, ignoring delegate callback");
         return;
     }
     
@@ -26,7 +27,7 @@ static NSString *g_outputPath = nil;
     if (error) {
         NSLog(@"❌ Stream error: %@", error);
     } else {
-        NSLog(@"✅ Stream stopped cleanly");
+        MRLog(@"✅ Stream stopped cleanly");
     }
     
     // Use dispatch_async to prevent potential deadlocks in Electron
@@ -50,7 +51,7 @@ static NSString *g_outputPath = nil;
 + (BOOL)startRecordingWithConfiguration:(NSDictionary *)config delegate:(id)delegate error:(NSError **)error {
     @synchronized([ScreenCaptureKitRecorder class]) {
         if (g_isRecording || g_isCleaningUp) {
-            NSLog(@"⚠️ Already recording or cleaning up (recording:%d cleaning:%d)", g_isRecording, g_isCleaningUp);
+        MRLog(@"⚠️ Already recording or cleaning up (recording:%d cleaning:%d)", g_isRecording, g_isCleaningUp);
             return NO;
         }
         
@@ -73,13 +74,13 @@ static NSString *g_outputPath = nil;
     NSNumber *includeMicrophone = config[@"includeMicrophone"];
     NSNumber *includeSystemAudio = config[@"includeSystemAudio"];
     
-    NSLog(@"🎬 Starting PURE ScreenCaptureKit recording (NO AVFoundation)");
-    NSLog(@"🔧 Config: cursor=%@ mic=%@ system=%@ display=%@ window=%@ crop=%@", 
+    MRLog(@"🎬 Starting PURE ScreenCaptureKit recording (NO AVFoundation)");
+    MRLog(@"🔧 Config: cursor=%@ mic=%@ system=%@ display=%@ window=%@ crop=%@", 
           captureCursor, includeMicrophone, includeSystemAudio, displayId, windowId, captureRect);
     
     // CRITICAL DEBUG: Log EXACT audio parameter values
-    NSLog(@"🔍 AUDIO DEBUG: includeMicrophone type=%@ value=%d", [includeMicrophone class], [includeMicrophone boolValue]);
-    NSLog(@"🔍 AUDIO DEBUG: includeSystemAudio type=%@ value=%d", [includeSystemAudio class], [includeSystemAudio boolValue]);
+    MRLog(@"🔍 AUDIO DEBUG: includeMicrophone type=%@ value=%d", [includeMicrophone class], [includeMicrophone boolValue]);
+    MRLog(@"🔍 AUDIO DEBUG: includeSystemAudio type=%@ value=%d", [includeSystemAudio class], [includeSystemAudio boolValue]);
     
     // Get shareable content
     [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
@@ -88,13 +89,13 @@ static NSString *g_outputPath = nil;
             return;
         }
         
-        NSLog(@"✅ Got %lu displays, %lu windows for pure recording", 
+        MRLog(@"✅ Got %lu displays, %lu windows for pure recording", 
               content.displays.count, content.windows.count);
         
         // CRITICAL DEBUG: List all available displays in ScreenCaptureKit
-        NSLog(@"🔍 ScreenCaptureKit available displays:");
+        MRLog(@"🔍 ScreenCaptureKit available displays:");
         for (SCDisplay *display in content.displays) {
-            NSLog(@"   Display ID=%u, Size=%dx%d, Frame=(%.0f,%.0f,%.0fx%.0f)", 
+            MRLog(@"   Display ID=%u, Size=%dx%d, Frame=(%.0f,%.0f,%.0fx%.0f)", 
                   display.displayID, (int)display.width, (int)display.height,
                   display.frame.origin.x, display.frame.origin.y,
                   display.frame.size.width, display.frame.size.height);
@@ -119,7 +120,7 @@ static NSString *g_outputPath = nil;
             }
             
             if (targetWindow && targetApp) {
-                NSLog(@"🪟 Recording window: %@ (%ux%u)", 
+                MRLog(@"🪟 Recording window: %@ (%ux%u)", 
                       targetWindow.title, (unsigned)targetWindow.frame.size.width, (unsigned)targetWindow.frame.size.height);
                 filter = [[SCContentFilter alloc] initWithDesktopIndependentWindow:targetWindow];
                 recordingWidth = (NSInteger)targetWindow.frame.size.width;
@@ -134,12 +135,12 @@ static NSString *g_outputPath = nil;
             
             if (displayId && [displayId integerValue] != 0) {
                 // Find specific display
-                NSLog(@"🎯 Looking for display ID=%@ in ScreenCaptureKit list", displayId);
+                MRLog(@"🎯 Looking for display ID=%@ in ScreenCaptureKit list", displayId);
                 for (SCDisplay *display in content.displays) {
-                    NSLog(@"   Checking display ID=%u vs requested=%u", display.displayID, [displayId unsignedIntValue]);
+                    MRLog(@"   Checking display ID=%u vs requested=%u", display.displayID, [displayId unsignedIntValue]);
                     if (display.displayID == [displayId unsignedIntValue]) {
                         targetDisplay = display;
-                        NSLog(@"✅ FOUND matching display ID=%u", display.displayID);
+                        MRLog(@"✅ FOUND matching display ID=%u", display.displayID);
                         break;
                     }
                 }
@@ -158,7 +159,7 @@ static NSString *g_outputPath = nil;
                 return;
             }
             
-            NSLog(@"🖥️ Recording display %u (%dx%d)", 
+            MRLog(@"🖥️ Recording display %u (%dx%d)", 
                   targetDisplay.displayID, (int)targetDisplay.width, (int)targetDisplay.height);
             filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:@[]];
             recordingWidth = targetDisplay.width;
@@ -171,7 +172,7 @@ static NSString *g_outputPath = nil;
             CGFloat cropHeight = [captureRect[@"height"] doubleValue];
             
             if (cropWidth > 0 && cropHeight > 0) {
-                NSLog(@"🔲 Crop area specified: %.0fx%.0f at (%.0f,%.0f)", 
+                MRLog(@"🔲 Crop area specified: %.0fx%.0f at (%.0f,%.0f)", 
                       cropWidth, cropHeight, 
                       [captureRect[@"x"] doubleValue], [captureRect[@"y"] doubleValue]);
                 recordingWidth = (NSInteger)cropWidth;
@@ -200,11 +201,11 @@ static NSString *g_outputPath = nil;
                 CGFloat displayRelativeX = globalX - displayBounds.origin.x;
                 CGFloat displayRelativeY = globalY - displayBounds.origin.y;
                 
-                NSLog(@"🌐 Global coords: (%.0f,%.0f) on Display ID=%u", globalX, globalY, targetDisplay.displayID);
-                NSLog(@"🖥️ Display bounds: (%.0f,%.0f,%.0fx%.0f)", 
+                MRLog(@"🌐 Global coords: (%.0f,%.0f) on Display ID=%u", globalX, globalY, targetDisplay.displayID);
+                MRLog(@"🖥️ Display bounds: (%.0f,%.0f,%.0fx%.0f)", 
                       displayBounds.origin.x, displayBounds.origin.y, 
                       displayBounds.size.width, displayBounds.size.height);
-                NSLog(@"📍 Display-relative: (%.0f,%.0f) -> SourceRect", displayRelativeX, displayRelativeY);
+                MRLog(@"📍 Display-relative: (%.0f,%.0f) -> SourceRect", displayRelativeX, displayRelativeY);
                 
                 // Validate coordinates are within display bounds
                 if (displayRelativeX >= 0 && displayRelativeY >= 0 && 
@@ -213,11 +214,11 @@ static NSString *g_outputPath = nil;
                     
                     CGRect sourceRect = CGRectMake(displayRelativeX, displayRelativeY, cropWidth, cropHeight);
                     streamConfig.sourceRect = sourceRect;
-                    NSLog(@"✂️ Crop sourceRect applied: (%.0f,%.0f) %.0fx%.0f (display-relative)", 
+                    MRLog(@"✂️ Crop sourceRect applied: (%.0f,%.0f) %.0fx%.0f (display-relative)", 
                           displayRelativeX, displayRelativeY, cropWidth, cropHeight);
                 } else {
                     NSLog(@"❌ Crop coordinates out of display bounds - skipping crop");
-                    NSLog(@"   Relative: (%.0f,%.0f) size:(%.0fx%.0f) vs display:(%.0fx%.0f)",
+                    MRLog(@"   Relative: (%.0f,%.0f) size:(%.0fx%.0f) vs display:(%.0fx%.0f)",
                           displayRelativeX, displayRelativeY, cropWidth, cropHeight,
                           displayBounds.size.width, displayBounds.size.height);
                 }
@@ -228,14 +229,14 @@ static NSString *g_outputPath = nil;
         BOOL shouldShowCursor = captureCursor ? [captureCursor boolValue] : YES;
         streamConfig.showsCursor = shouldShowCursor;
         
-        NSLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ 30fps, cursor=%d", 
+        MRLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ 30fps, cursor=%d", 
               recordingWidth, recordingHeight, shouldShowCursor);
         
         // AUDIO SUPPORT - Enable both microphone and system audio
-        NSLog(@"🔍 AUDIO PROCESSING: includeMicrophone=%@ includeSystemAudio=%@", includeMicrophone, includeSystemAudio);
+        MRLog(@"🔍 AUDIO PROCESSING: includeMicrophone=%@ includeSystemAudio=%@", includeMicrophone, includeSystemAudio);
         BOOL shouldCaptureMic = includeMicrophone ? [includeMicrophone boolValue] : NO;
         BOOL shouldCaptureSystemAudio = includeSystemAudio ? [includeSystemAudio boolValue] : NO;
-        NSLog(@"🔍 AUDIO COMPUTED: shouldCaptureMic=%d shouldCaptureSystemAudio=%d", shouldCaptureMic, shouldCaptureSystemAudio);
+        MRLog(@"🔍 AUDIO COMPUTED: shouldCaptureMic=%d shouldCaptureSystemAudio=%d", shouldCaptureMic, shouldCaptureSystemAudio);
         
         // Enable audio if either microphone or system audio is requested
         if (@available(macOS 13.0, *)) {
@@ -245,19 +246,19 @@ static NSString *g_outputPath = nil;
                 streamConfig.channelCount = 2;
                 
                 if (shouldCaptureMic && shouldCaptureSystemAudio) {
-                    NSLog(@"🎵 Both microphone and system audio enabled");
+                    MRLog(@"🎵 Both microphone and system audio enabled");
                 } else if (shouldCaptureMic) {
-                    NSLog(@"🎤 Microphone audio enabled");
+                    MRLog(@"🎤 Microphone audio enabled");
                 } else {
-                    NSLog(@"🔊 System audio enabled");
+                    MRLog(@"🔊 System audio enabled");
                 }
             } else {
                 streamConfig.capturesAudio = NO;
-                NSLog(@"🔇 Audio disabled");
+                MRLog(@"🔇 Audio disabled");
             }
         } else {
             streamConfig.capturesAudio = NO;
-            NSLog(@"🔇 Audio disabled (macOS < 13.0)");
+            MRLog(@"🔇 Audio disabled (macOS < 13.0)");
         }
         
         // Create pure ScreenCaptureKit recording output
@@ -328,7 +329,7 @@ static NSString *g_outputPath = nil;
             return;
         }
         
-        NSLog(@"✅ Pure recording output added to stream");
+        MRLog(@"✅ Pure recording output added to stream");
         
         // Start capture with recording
         [g_stream startCaptureWithCompletionHandler:^(NSError *startError) {
@@ -336,7 +337,7 @@ static NSString *g_outputPath = nil;
                 NSLog(@"❌ Failed to start pure capture: %@", startError);
                 g_isRecording = NO;
             } else {
-                NSLog(@"🎉 PURE ScreenCaptureKit recording started successfully!");
+                MRLog(@"🎉 PURE ScreenCaptureKit recording started successfully!");
                 g_isRecording = YES;
             }
         }];
@@ -351,7 +352,7 @@ static NSString *g_outputPath = nil;
         return;
     }
     
-    NSLog(@"🛑 Stopping pure ScreenCaptureKit recording");
+    MRLog(@"🛑 Stopping pure ScreenCaptureKit recording");
     
     // Store stream reference to prevent it from being deallocated
     SCStream *streamToStop = g_stream;
@@ -360,7 +361,7 @@ static NSString *g_outputPath = nil;
         if (error) {
             NSLog(@"❌ Stop error: %@", error);
         }
-        NSLog(@"✅ Pure stream stopped");
+        MRLog(@"✅ Pure stream stopped");
         
         // Immediately reset recording state to allow new recordings
         g_isRecording = NO;
@@ -383,7 +384,7 @@ static NSString *g_outputPath = nil;
 
 + (void)finalizeRecording {
     @synchronized([ScreenCaptureKitRecorder class]) {
-        NSLog(@"🎬 Finalizing pure ScreenCaptureKit recording");
+        MRLog(@"🎬 Finalizing pure ScreenCaptureKit recording");
         
         // Set cleanup flag now that we're actually cleaning up
         g_isCleaningUp = YES;
@@ -391,7 +392,7 @@ static NSString *g_outputPath = nil;
         
         if (g_recordingOutput) {
             // SCRecordingOutput finalizes automatically
-            NSLog(@"✅ Pure recording output finalized");
+            MRLog(@"✅ Pure recording output finalized");
         }
         
         [ScreenCaptureKitRecorder cleanupVideoWriter];
@@ -405,30 +406,30 @@ static NSString *g_outputPath = nil;
 
 + (void)cleanupVideoWriter {
     @synchronized([ScreenCaptureKitRecorder class]) {
-        NSLog(@"🧹 Starting ScreenCaptureKit cleanup");
+        MRLog(@"🧹 Starting ScreenCaptureKit cleanup");
         
         // Clean up in proper order to prevent crashes
         if (g_stream) {
             g_stream = nil;
-            NSLog(@"✅ Stream reference cleared");
+            MRLog(@"✅ Stream reference cleared");
         }
         
         if (g_recordingOutput) {
             g_recordingOutput = nil;
-            NSLog(@"✅ Recording output reference cleared");
+            MRLog(@"✅ Recording output reference cleared");
         }
         
         if (g_streamDelegate) {
             g_streamDelegate = nil;
-            NSLog(@"✅ Stream delegate reference cleared");
+            MRLog(@"✅ Stream delegate reference cleared");
         }
         
         g_isRecording = NO;
         g_isCleaningUp = NO;  // Reset cleanup flag
         g_outputPath = nil;
         
-        NSLog(@"🧹 Pure ScreenCaptureKit cleanup complete");
+        MRLog(@"🧹 Pure ScreenCaptureKit cleanup complete");
     }
 }
 
-@end
+@end