node-mac-recorder 2.17.10 → 2.17.12

package/.claude/settings.local.json

@@ -4,7 +4,9 @@
       "Bash(node:*)",
       "Bash(chmod:*)",
       "Bash(cat:*)",
-      "Bash(git checkout:*)"
+      "Bash(git checkout:*)",
+      "WebSearch",
+      "WebFetch(domain:stackoverflow.com)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -31,8 +31,6 @@ class MacRecorder extends EventEmitter {
 		this.cursorCaptureFile = null;
 		this.cursorCaptureStartTime = null;
 		this.cursorCaptureFirstWrite = true;
-		this.cursorRecordingBaseTime = null;
-		this.cursorRecordingOffsetMs = 0;
 		this.lastCapturedData = null;
 		this.cursorDisplayInfo = null;
 		this.recordingDisplayInfo = null;
@@ -43,7 +41,7 @@ class MacRecorder extends EventEmitter {
 			quality: "medium",
 			frameRate: 30,
 			captureArea: null, // { x, y, width, height }
-			captureCursor: false, // Default: cursor hidden in video
+			captureCursor: false, // Default olarak cursor gizli
 			showClicks: false,
 			displayId: null, // Hangi ekranı kaydedeceği (null = ana ekran)
 			windowId: null, // Hangi pencereyi kaydedeceği (null = tam ekran)
@@ -81,29 +79,16 @@ class MacRecorder extends EventEmitter {
 	 */
 	async getDisplays() {
 		const displays = nativeBinding.getDisplays();
-		return displays.map((display, index) => {
-			const logicalWidth = Number(display.width) || 0;
-			const logicalHeight = Number(display.height) || 0;
-			const pixelWidth = Number(display.pixelWidth) || logicalWidth;
-			const pixelHeight = Number(display.pixelHeight) || logicalHeight;
-			const scaleX = display.scaleX ? Number(display.scaleX) : (logicalWidth > 0 ? pixelWidth / logicalWidth : 1);
-			const scaleY = display.scaleY ? Number(display.scaleY) : (logicalHeight > 0 ? pixelHeight / logicalHeight : 1);
-
-			return {
-				id: display.id, // Use the actual display ID from native code
-				name: display.name,
-				width: logicalWidth,
-				height: logicalHeight,
-				pixelWidth,
-				pixelHeight,
-				scaleX,
-				scaleY,
-				x: display.x,
-				y: display.y,
-				isPrimary: display.isPrimary,
-				resolution: `${logicalWidth}x${logicalHeight}`,
-			};
-		});
+		return displays.map((display, index) => ({
+			id: display.id, // Use the actual display ID from native code
+			name: display.name,
+			width: display.width,
+			height: display.height,
+			x: display.x,
+			y: display.y,
+			isPrimary: display.isPrimary,
+			resolution: `${display.width}x${display.height}`,
+		}));
 	}
 
 	/**
@@ -267,29 +252,16 @@ class MacRecorder extends EventEmitter {
 
 						// Recording için display bilgisini sakla (cursor capture için)
 						const targetDisplay = displays.find(d => d.id === targetDisplayId);
-						if (targetDisplay) {
-							const logicalWidth = Number(targetDisplay.width) || parseInt(targetDisplay.resolution.split("x")[0]);
-							const logicalHeight = Number(targetDisplay.height) || parseInt(targetDisplay.resolution.split("x")[1]);
-							const pixelWidth = Number(targetDisplay.pixelWidth) || logicalWidth;
-							const pixelHeight = Number(targetDisplay.pixelHeight) || logicalHeight;
-							const scaleX = Number.isFinite(targetDisplay.scaleX) ? Number(targetDisplay.scaleX) : (logicalWidth > 0 ? pixelWidth / logicalWidth : 1);
-							const scaleY = Number.isFinite(targetDisplay.scaleY) ? Number(targetDisplay.scaleY) : (logicalHeight > 0 ? pixelHeight / logicalHeight : 1);
-
-							this.recordingDisplayInfo = {
-								displayId: targetDisplayId,
-								x: targetDisplay.x,
-								y: targetDisplay.y,
-								width: logicalWidth,
-								height: logicalHeight,
-								pixelWidth,
-								pixelHeight,
-								scaleX,
-								scaleY,
-								// Add scaling information for cursor coordinate transformation
-								logicalWidth,
-								logicalHeight,
-							};
-						}
+						this.recordingDisplayInfo = {
+							displayId: targetDisplayId,
+							x: targetDisplay.x,
+							y: targetDisplay.y,
+							width: parseInt(targetDisplay.resolution.split("x")[0]),
+							height: parseInt(targetDisplay.resolution.split("x")[1]),
+							// Add scaling information for cursor coordinate transformation
+							logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
+							logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
+						};
 					}
 
 					this.options.captureArea = {
@@ -317,26 +289,15 @@ class MacRecorder extends EventEmitter {
 				const displays = await this.getDisplays();
 				const targetDisplay = displays.find(d => d.id === this.options.displayId);
 				if (targetDisplay) {
-					const logicalWidth = Number(targetDisplay.width) || parseInt(targetDisplay.resolution.split("x")[0]);
-					const logicalHeight = Number(targetDisplay.height) || parseInt(targetDisplay.resolution.split("x")[1]);
-					const pixelWidth = Number(targetDisplay.pixelWidth) || logicalWidth;
-					const pixelHeight = Number(targetDisplay.pixelHeight) || logicalHeight;
-					const scaleX = Number.isFinite(targetDisplay.scaleX) ? Number(targetDisplay.scaleX) : (logicalWidth > 0 ? pixelWidth / logicalWidth : 1);
-					const scaleY = Number.isFinite(targetDisplay.scaleY) ? Number(targetDisplay.scaleY) : (logicalHeight > 0 ? pixelHeight / logicalHeight : 1);
-
 					this.recordingDisplayInfo = {
 						displayId: this.options.displayId,
 						x: targetDisplay.x,
 						y: targetDisplay.y,
-						width: logicalWidth,
-						height: logicalHeight,
-						pixelWidth,
-						pixelHeight,
-						scaleX,
-						scaleY,
+						width: parseInt(targetDisplay.resolution.split("x")[0]),
+						height: parseInt(targetDisplay.resolution.split("x")[1]),
 						// Add scaling information for cursor coordinate transformation
-						logicalWidth,
-						logicalHeight,
+						logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
+						logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
 					};
 				}
 			} catch (error) {
@@ -395,105 +356,51 @@ class MacRecorder extends EventEmitter {
 					this.isRecording = true;
 					this.recordingStartTime = Date.now();
 
-						// Start cursor tracking automatically with recording
-						// For window recording, align cursor coordinates against actual capture geometry
-						if (this.options.windowId) {
-							const waitForActiveCaptureInfo = async () => {
-								if (typeof nativeBinding.getActiveCaptureInfo !== "function") {
-									return null;
-								}
-
-								const maxAttempts = 30;
-								for (let attempt = 0; attempt < maxAttempts; attempt++) {
-									try {
-										const info = nativeBinding.getActiveCaptureInfo();
-										if (info && typeof info === "object" && Object.keys(info).length > 0) {
-											return info;
-										}
-									} catch (nativeInfoError) {
-										if (attempt === 0) {
-											console.warn('getActiveCaptureInfo failed:', nativeInfoError.message);
-										}
+					// Start cursor tracking automatically with recording
+					let cursorOptions = {};
+
+					// For window recording, use simplified window-relative coordinates
+					if (this.options.windowId) {
+						// Use cached window info from the earlier window detection
+						this.getWindows().then(windows => {
+							const targetWindow = windows.find(w => w.id === this.options.windowId);
+							if (targetWindow) {
+								// Start cursor capture with simplified window-relative tracking
+								this.startCursorCapture(cursorFilePath, {
+									windowRelative: true,
+									windowInfo: {
+										// Use original global window coordinates for reference
+										x: targetWindow.x,
+										y: targetWindow.y,
+										width: targetWindow.width,
+										height: targetWindow.height,
+										displayId: this.options.displayId,
+										// Persist capture area so we can rebuild global offsets reliably
+										captureArea: this.options.captureArea,
+										// Keep a snapshot of the window details for debugging/analytics
+										originalWindow: targetWindow,
+										// Store display info for multi-display coordinate fixes
+										targetDisplay: this.recordingDisplayInfo
 									}
-
-									await new Promise((resolve) => setTimeout(resolve, 20));
-								}
-
-								return null;
-							};
-
-							const startWindowCursorTracking = async () => {
-								try {
-									const [windows, activeCaptureInfo] = await Promise.all([
-										this.getWindows(),
-										waitForActiveCaptureInfo()
-									]);
-
-									const targetWindow = windows.find(w => w.id === this.options.windowId);
-									if (!targetWindow) {
-										throw new Error('Target window not found for cursor tracking');
-									}
-
-									const hasNumber = (value) => typeof value === "number" && Number.isFinite(value);
-									const targetDisplay = this.recordingDisplayInfo;
-									const nativeWindowFrame = activeCaptureInfo?.type === 'window' ? activeCaptureInfo.window?.frame : null;
-
-									const windowWidth = hasNumber(nativeWindowFrame?.width) ? nativeWindowFrame.width : targetWindow.width;
-									const windowHeight = hasNumber(nativeWindowFrame?.height) ? nativeWindowFrame.height : targetWindow.height;
-
-									let captureAreaForCursor = this.options.captureArea;
-									let globalWindowX = targetWindow.x;
-									let globalWindowY = targetWindow.y;
-
-									if (nativeWindowFrame && hasNumber(nativeWindowFrame.x) && hasNumber(nativeWindowFrame.y)) {
-										globalWindowX = nativeWindowFrame.x;
-										globalWindowY = nativeWindowFrame.y;
-
-										if (targetDisplay && hasNumber(targetDisplay.x) && hasNumber(targetDisplay.y)) {
-											captureAreaForCursor = {
-												x: nativeWindowFrame.x - targetDisplay.x,
-												y: nativeWindowFrame.y - targetDisplay.y,
-												width: windowWidth,
-												height: windowHeight
-											};
-											this.options.captureArea = captureAreaForCursor;
-										}
-									}
-
-									// Start cursor capture with geometry-aware window-relative tracking
-									this.startCursorCapture(cursorFilePath, {
-										windowRelative: true,
-										windowInfo: {
-											x: globalWindowX,
-											y: globalWindowY,
-											width: windowWidth,
-											height: windowHeight,
-											displayId: this.options.displayId,
-											captureArea: captureAreaForCursor,
-											originalWindow: targetWindow,
-											targetDisplay,
-											nativeFrame: nativeWindowFrame
-										}
-									}).catch(cursorError => {
-										console.warn('Window cursor tracking failed:', cursorError.message);
-										// Fallback to display recording
-										this.startCursorCapture(cursorFilePath).catch(fallbackError => {
-											console.warn('Fallback cursor tracking failed:', fallbackError.message);
-										});
-									});
-								} catch (error) {
-									console.warn('Could not prepare window cursor tracking:', error.message);
-									this.startCursorCapture(cursorFilePath).catch(cursorError => {
-										console.warn('Cursor tracking failed to start:', cursorError.message);
+								}).catch(cursorError => {
+									console.warn('Window cursor tracking failed:', cursorError.message);
+									// Fallback to display recording
+									this.startCursorCapture(cursorFilePath).catch(fallbackError => {
+										console.warn('Fallback cursor tracking failed:', fallbackError.message);
 									});
-								}
-							};
-
-							startWindowCursorTracking();
-						} else {
-							// For display recording, use display-relative cursor tracking
-							this.startCursorCapture(cursorFilePath, {
-								displayRelative: true,
+								});
+							}
+						}).catch(error => {
+							console.warn('Could not get window info for cursor tracking:', error.message);
+							// Fallback to display cursor tracking
+							this.startCursorCapture(cursorFilePath).catch(cursorError => {
+								console.warn('Cursor tracking failed to start:', cursorError.message);
+							});
+						});
+					} else {
+						// For display recording, use display-relative cursor tracking
+						this.startCursorCapture(cursorFilePath, {
+							displayRelative: true,
 							displayInfo: this.recordingDisplayInfo
 						}).catch(cursorError => {
 							console.warn('Display cursor tracking failed:', cursorError.message);
@@ -805,16 +712,6 @@ class MacRecorder extends EventEmitter {
 			const targetDisplay = windowInfo.targetDisplay || this.recordingDisplayInfo || null;
 			const captureArea = windowInfo.captureArea || null;
 			const hasNumber = (value) => typeof value === "number" && Number.isFinite(value);
-			const displayScaleX = targetDisplay && hasNumber(targetDisplay.scaleX)
-				? Number(targetDisplay.scaleX)
-				: (targetDisplay && hasNumber(targetDisplay.pixelWidth) && hasNumber(targetDisplay.width)
-					? targetDisplay.pixelWidth / targetDisplay.width
-					: 1);
-			const displayScaleY = targetDisplay && hasNumber(targetDisplay.scaleY)
-				? Number(targetDisplay.scaleY)
-				: (targetDisplay && hasNumber(targetDisplay.pixelHeight) && hasNumber(targetDisplay.height)
-					? targetDisplay.pixelHeight / targetDisplay.height
-					: 1);
 
 			let globalX = hasNumber(windowInfo.x) ? windowInfo.x : null;
 			let globalY = hasNumber(windowInfo.y) ? windowInfo.y : null;
@@ -848,40 +745,12 @@ class MacRecorder extends EventEmitter {
 				? captureArea.x
 				: (targetDisplay && hasNumber(globalX) && hasNumber(targetDisplay.x)
 					? globalX - targetDisplay.x
-					: globalX ?? 0);
+					: globalX);
 			const displayOffsetY = captureArea && hasNumber(captureArea.y)
 				? captureArea.y
 				: (targetDisplay && hasNumber(globalY) && hasNumber(targetDisplay.y)
 					? globalY - targetDisplay.y
-					: globalY ?? 0);
-
-			const windowPixelWidth = hasNumber(windowInfo.width) ? windowInfo.width * displayScaleX : null;
-			const windowPixelHeight = hasNumber(windowInfo.height) ? windowInfo.height * displayScaleY : null;
-			const captureAreaInfo = captureArea
-				? {
-					...captureArea,
-					pixelX: hasNumber(captureArea.x) ? captureArea.x * displayScaleX : null,
-					pixelY: hasNumber(captureArea.y) ? captureArea.y * displayScaleY : null,
-					pixelWidth: hasNumber(captureArea.width) ? captureArea.width * displayScaleX : windowPixelWidth,
-					pixelHeight: hasNumber(captureArea.height) ? captureArea.height * displayScaleY : windowPixelHeight,
-				}
-				: null;
-
-			const enrichedWindowInfo = {
-				...windowInfo,
-				globalX,
-				globalY,
-				displayOffsetX,
-				displayOffsetY,
-				scaleX: displayScaleX,
-				scaleY: displayScaleY,
-				pixelWidth: windowPixelWidth,
-				pixelHeight: windowPixelHeight,
-			};
-
-			if (captureAreaInfo) {
-				enrichedWindowInfo.captureArea = captureAreaInfo;
-			}
+					: globalY);
 
 			this.cursorDisplayInfo = {
 				displayId:
@@ -893,40 +762,25 @@ class MacRecorder extends EventEmitter {
 				y: globalY,
 				width: windowInfo.width,
 				height: windowInfo.height,
-				pixelWidth: windowPixelWidth,
-				pixelHeight: windowPixelHeight,
-				scaleX: displayScaleX,
-				scaleY: displayScaleY,
-				displayRelativeX: displayOffsetX,
-				displayRelativeY: displayOffsetY,
 				windowRelative: true,
 				windowInfo: {
-					...enrichedWindowInfo
+					...windowInfo,
+					globalX,
+					globalY,
+					displayOffsetX,
+					displayOffsetY
 				},
 				targetDisplay,
-				captureArea: captureAreaInfo
+				captureArea
 			};
 		} else if (options.displayRelative && options.displayInfo) {
 			// Display recording: Use display-relative coordinates
-			const pixelWidth = Number(options.displayInfo.pixelWidth) || Number(options.displayInfo.width);
-			const pixelHeight = Number(options.displayInfo.pixelHeight) || Number(options.displayInfo.height);
-			const scaleX = Number.isFinite(options.displayInfo.scaleX)
-				? Number(options.displayInfo.scaleX)
-				: (Number(options.displayInfo.width) > 0 ? pixelWidth / Number(options.displayInfo.width) : 1);
-			const scaleY = Number.isFinite(options.displayInfo.scaleY)
-				? Number(options.displayInfo.scaleY)
-				: (Number(options.displayInfo.height) > 0 ? pixelHeight / Number(options.displayInfo.height) : 1);
-
 			this.cursorDisplayInfo = {
 				displayId: options.displayInfo.displayId,
 				x: options.displayInfo.x,
 				y: options.displayInfo.y,
 				width: options.displayInfo.width,
 				height: options.displayInfo.height,
-				pixelWidth,
-				pixelHeight,
-				scaleX,
-				scaleY,
 				displayRelative: true
 			};
 		} else if (this.recordingDisplayInfo) {
@@ -942,16 +796,8 @@ class MacRecorder extends EventEmitter {
 						displayId: mainDisplay.id,
 						x: mainDisplay.x,
 						y: mainDisplay.y,
-						width: Number(mainDisplay.width) || parseInt(mainDisplay.resolution.split("x")[0]),
-						height: Number(mainDisplay.height) || parseInt(mainDisplay.resolution.split("x")[1]),
-						pixelWidth: Number(mainDisplay.pixelWidth) || Number(mainDisplay.width) || parseInt(mainDisplay.resolution.split("x")[0]),
-						pixelHeight: Number(mainDisplay.pixelHeight) || Number(mainDisplay.height) || parseInt(mainDisplay.resolution.split("x")[1]),
-						scaleX: Number.isFinite(mainDisplay.scaleX)
-							? Number(mainDisplay.scaleX)
-							: ((Number(mainDisplay.width) || 0) > 0 ? (Number(mainDisplay.pixelWidth) || Number(mainDisplay.width)) / Number(mainDisplay.width) : 1),
-						scaleY: Number.isFinite(mainDisplay.scaleY)
-							? Number(mainDisplay.scaleY)
-							: ((Number(mainDisplay.height) || 0) > 0 ? (Number(mainDisplay.pixelHeight) || Number(mainDisplay.height)) / Number(mainDisplay.height) : 1),
+						width: parseInt(mainDisplay.resolution.split("x")[0]),
+						height: parseInt(mainDisplay.resolution.split("x")[1]),
 					};
 				}
 			} catch (error) {
@@ -967,24 +813,15 @@ class MacRecorder extends EventEmitter {
 				fs.writeFileSync(filepath, "[");
 
 				this.cursorCaptureFile = filepath;
-				const captureStart = Date.now();
-				const recordingBase = this.isRecording && this.recordingStartTime
-					? this.recordingStartTime
-					: captureStart;
-				this.cursorCaptureStartTime = captureStart;
-				this.cursorRecordingBaseTime = recordingBase;
-				this.cursorRecordingOffsetMs = Math.max(0, captureStart - recordingBase);
+				this.cursorCaptureStartTime = Date.now();
 				this.cursorCaptureFirstWrite = true;
 				this.lastCapturedData = null;
 
 				// JavaScript interval ile polling yap (daha sık - mouse event'leri yakalamak için)
 				this.cursorCaptureInterval = setInterval(() => {
 					try {
-						const now = Date.now();
 						const position = nativeBinding.getCursorPosition();
-						const captureTimestamp = this.cursorCaptureStartTime ? now - this.cursorCaptureStartTime : 0;
-						const recordingBase = this.cursorRecordingBaseTime || this.cursorCaptureStartTime || now;
-						const recordingTimestamp = Math.max(0, now - recordingBase);
+						const timestamp = Date.now() - this.cursorCaptureStartTime;
 
 						// Transform coordinates based on recording type
 						let x = position.x;
@@ -993,30 +830,9 @@ class MacRecorder extends EventEmitter {
 
 						if (this.cursorDisplayInfo) {
 							if (this.cursorDisplayInfo.windowRelative) {
-								// Window recording: base on display-relative offsets when available
-								const captureArea = this.cursorDisplayInfo.captureArea || this.cursorDisplayInfo.windowInfo?.captureArea;
-								const targetDisplay = this.cursorDisplayInfo.targetDisplay || this.recordingDisplayInfo;
-								const hasCoord = (value) => typeof value === "number" && Number.isFinite(value);
-
-								if (targetDisplay && captureArea && hasCoord(captureArea.x) && hasCoord(captureArea.y)) {
-									const displayRelativeX = position.x - targetDisplay.x;
-									const displayRelativeY = position.y - targetDisplay.y;
-									x = displayRelativeX - captureArea.x;
-									y = displayRelativeY - captureArea.y;
-								} else if (
-									hasCoord(this.cursorDisplayInfo.displayRelativeX) &&
-									hasCoord(this.cursorDisplayInfo.displayRelativeY) &&
-									targetDisplay
-								) {
-									const displayRelativeX = position.x - targetDisplay.x;
-									const displayRelativeY = position.y - targetDisplay.y;
-									x = displayRelativeX - this.cursorDisplayInfo.displayRelativeX;
-									y = displayRelativeY - this.cursorDisplayInfo.displayRelativeY;
-								} else {
-									// Fallback: global offsets
-									x = position.x - this.cursorDisplayInfo.x;
-									y = position.y - this.cursorDisplayInfo.y;
-								}
+								// Window recording: Transform global → window-relative coordinates
+								x = position.x - this.cursorDisplayInfo.x;
+								y = position.y - this.cursorDisplayInfo.y;
 								coordinateSystem = "window-relative";
 
 								// Window bounds check - skip if cursor is outside window
@@ -1041,28 +857,11 @@ class MacRecorder extends EventEmitter {
 							}
 						}
 
-						const logicalX = x;
-						const logicalY = y;
-						const scaleX = Number.isFinite(this.cursorDisplayInfo?.windowInfo?.scaleX)
-							? Number(this.cursorDisplayInfo.windowInfo.scaleX)
-							: (Number.isFinite(this.cursorDisplayInfo?.scaleX) ? Number(this.cursorDisplayInfo.scaleX) : 1);
-						const scaleY = Number.isFinite(this.cursorDisplayInfo?.windowInfo?.scaleY)
-							? Number(this.cursorDisplayInfo.windowInfo.scaleY)
-							: (Number.isFinite(this.cursorDisplayInfo?.scaleY) ? Number(this.cursorDisplayInfo.scaleY) : 1);
-						const pixelX = logicalX * scaleX;
-						const pixelY = logicalY * scaleY;
-
 						const cursorData = {
-							x: logicalX,
-							y: logicalY,
-							pixelX,
-							pixelY,
-							scaleX,
-							scaleY,
-							timestamp: recordingTimestamp,
-							captureTimestamp,
-							recordingOffsetMs: this.cursorRecordingOffsetMs,
-							unixTimeMs: now,
+							x: x,
+							y: y,
+							timestamp: timestamp,
+							unixTimeMs: Date.now(),
 							cursorType: position.cursorType,
 							type: position.eventType || "move",
 							coordinateSystem: coordinateSystem,
@@ -1071,14 +870,7 @@ class MacRecorder extends EventEmitter {
 								windowInfo: {
 									width: this.cursorDisplayInfo.width,
 									height: this.cursorDisplayInfo.height,
-									pixelWidth: this.cursorDisplayInfo.pixelWidth ?? (this.cursorDisplayInfo.width * scaleX),
-									pixelHeight: this.cursorDisplayInfo.pixelHeight ?? (this.cursorDisplayInfo.height * scaleY),
-									displayId: this.cursorDisplayInfo.displayId,
-									displayOffsetX: this.cursorDisplayInfo.displayRelativeX,
-									displayOffsetY: this.cursorDisplayInfo.displayRelativeY,
-									scaleX,
-									scaleY,
-									captureArea: this.cursorDisplayInfo.captureArea || null
+									displayId: this.cursorDisplayInfo.displayId
 								}
 							}),
 							// Include display context for display-relative coordinates
@@ -1086,11 +878,7 @@ class MacRecorder extends EventEmitter {
 								displayInfo: {
 									displayId: this.cursorDisplayInfo.displayId,
 									width: this.cursorDisplayInfo.width,
-									height: this.cursorDisplayInfo.height,
-									pixelWidth: this.cursorDisplayInfo.pixelWidth ?? (this.cursorDisplayInfo.width * scaleX),
-									pixelHeight: this.cursorDisplayInfo.pixelHeight ?? (this.cursorDisplayInfo.height * scaleY),
-									scaleX,
-									scaleY
+									height: this.cursorDisplayInfo.height
 								}
 							})
 						};
@@ -1149,8 +937,6 @@ class MacRecorder extends EventEmitter {
 				this.cursorCaptureStartTime = null;
 				this.cursorCaptureFirstWrite = true;
 				this.cursorDisplayInfo = null;
-				this.cursorRecordingBaseTime = null;
-				this.cursorRecordingOffsetMs = 0;
 
 				this.emit("cursorCaptureStopped");
 				resolve(true);
@@ -1276,8 +1062,6 @@ class MacRecorder extends EventEmitter {
 			isCapturing: !!this.cursorCaptureInterval,
 			outputFile: this.cursorCaptureFile || null,
 			startTime: this.cursorCaptureStartTime || null,
-			recordingBaseTime: this.cursorRecordingBaseTime || null,
-			recordingOffsetMs: this.cursorRecordingOffsetMs || 0,
 			displayInfo: this.cursorDisplayInfo || null,
 		};
 	}

package/package.json

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

package/src/cursor_tracker.mm

@@ -35,9 +35,17 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint);
 
 static CursorTimerTarget *g_timerTarget = nil;
 
-// Global cursor state tracking
+// Enhanced cursor state tracking with stability
 static NSString *g_lastDetectedCursorType = nil;
+static NSString *g_stableCursorType = @"default";
 static int g_cursorTypeCounter = 0;
+static NSTimeInterval g_lastCursorCheckTime = 0;
+static int g_sameCursorDetectionCount = 0;
+static NSString *g_pendingCursorType = nil;
+
+// Cursor stability constants
+static const NSTimeInterval CURSOR_STABILITY_THRESHOLD = 0.1; // 100ms
+static const int CURSOR_CONFIRMATION_COUNT = 2; // Need 2 consecutive detections
 
 // Mouse button state tracking
 static bool g_leftMouseDown = false;
@@ -49,255 +57,145 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Cursor type detection helper - sistem genelindeki cursor type'ı al
+// Enhanced cursor type detection with multi-layer approach and stability
+NSString* detectCursorTypeFromNSCursor() {
+    @try {
+        NSCursor *currentCursor = [NSCursor currentSystemCursor];
+        if (!currentCursor) {
+            return @"default";
+        }
+
+        // Compare with known system cursors using identity comparison
+        if (currentCursor == [NSCursor arrowCursor]) {
+            return @"default";
+        } else if (currentCursor == [NSCursor IBeamCursor]) {
+            return @"text";
+        } else if (currentCursor == [NSCursor pointingHandCursor]) {
+            return @"pointer";
+        } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
+            return @"col-resize";
+        } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
+            return @"ns-resize";
+        } else if (currentCursor == [NSCursor crosshairCursor]) {
+            return @"crosshair";
+        } else if (currentCursor == [NSCursor openHandCursor]) {
+            return @"grab";
+        } else if (currentCursor == [NSCursor closedHandCursor]) {
+            return @"grabbing";
+        } else if (currentCursor == [NSCursor operationNotAllowedCursor]) {
+            return @"not-allowed";
+        }
+
+        // Fallback to image-based comparison for custom cursors
+        NSImage *cursorImage = [currentCursor image];
+        if (cursorImage) {
+            NSSize imageSize = [cursorImage size];
+
+            // Text cursors typically have I-beam shape (narrow width)
+            if (imageSize.width < 8 && imageSize.height > 15) {
+                return @"text";
+            }
+            // Pointer cursors are typically hand-shaped
+            else if (imageSize.width > 15 && imageSize.height > 15) {
+                return @"pointer";
+            }
+        }
+
+        return @"default";
+    } @catch (NSException *exception) {
+        return @"default";
+    }
+}
+
+// Improved cursor type detection with stability and multi-layer approach
 NSString* getCursorType() {
     @autoreleasepool {
         g_cursorTypeCounter++;
-        
-        @try {
-            // ACCESSIBILITY API BASED CURSOR DETECTION
-            // Determine cursor type based on the UI element under the cursor
-
-            CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
-            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
-            AXUIElementRef elementAtPosition = NULL;
-            AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
-
-            NSString *cursorType = @"default"; // Default fallback
-
-            if (error == kAXErrorSuccess && elementAtPosition) {
-                CFStringRef role = NULL;
-                error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
-
-                if (error == kAXErrorSuccess && role) {
-                    NSString *elementRole = (__bridge_transfer NSString*)role;
-                    NSLog(@"🎯 ELEMENT ROLE: %@", elementRole);
-
-                    // TEXT CURSORS
-                    if ([elementRole isEqualToString:@"AXTextField"] ||
-                        [elementRole isEqualToString:@"AXTextArea"] ||
-                        [elementRole isEqualToString:@"AXStaticText"] ||
-                        [elementRole isEqualToString:@"AXSearchField"]) {
-                        cursorType = @"text";
-                    }
-                    // POINTER CURSORS (clickable elements)
-                    else if ([elementRole isEqualToString:@"AXLink"] ||
-                             [elementRole isEqualToString:@"AXButton"] ||
-                             [elementRole isEqualToString:@"AXMenuItem"] ||
-                             [elementRole isEqualToString:@"AXRadioButton"] ||
-                             [elementRole isEqualToString:@"AXCheckBox"] ||
-                             [elementRole isEqualToString:@"AXPopUpButton"] ||
-                             [elementRole isEqualToString:@"AXTab"]) {
-                        cursorType = @"pointer";
-                    }
-                    // GRAB CURSORS (draggable elements)
-                    else if ([elementRole isEqualToString:@"AXImage"] ||
-                             [elementRole isEqualToString:@"AXGroup"]) {
-                        // Check if element is draggable
-                        CFBooleanRef draggable = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXMovable"), (CFTypeRef*)&draggable);
-                        if (error == kAXErrorSuccess && draggable && CFBooleanGetValue(draggable)) {
-                            cursorType = @"grab";
-                        } else {
-                            cursorType = @"default";
-                        }
-                    }
-                    // PROGRESS CURSORS (loading/busy elements)
-                    else if ([elementRole isEqualToString:@"AXProgressIndicator"] ||
-                             [elementRole isEqualToString:@"AXBusyIndicator"]) {
-                        cursorType = @"progress";
-                    }
-                    // HELP CURSORS (help buttons/tooltips)
-                    else if ([elementRole isEqualToString:@"AXHelpTag"] ||
-                             [elementRole isEqualToString:@"AXTooltip"]) {
-                        cursorType = @"help";
-                    }
-                    // RESIZE CURSORS - sadece AXSplitter için
-                    else if ([elementRole isEqualToString:@"AXSplitter"]) {
-                        // Get splitter orientation to determine resize direction
-                        CFStringRef orientation = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXOrientation"), (CFTypeRef*)&orientation);
-                        if (error == kAXErrorSuccess && orientation) {
-                            NSString *orientationStr = (__bridge_transfer NSString*)orientation;
-                            if ([orientationStr isEqualToString:@"AXHorizontalOrientation"]) {
-                                cursorType = @"ns-resize"; // Yatay splitter -> dikey hareket (north-south)
-                            } else if ([orientationStr isEqualToString:@"AXVerticalOrientation"]) {
-                                cursorType = @"col-resize"; // Dikey splitter -> yatay hareket (east-west)
-                            } else {
-                                cursorType = @"default"; // Bilinmeyen orientation
-                            }
-                        } else {
-                            cursorType = @"default"; // Orientation alınamazsa default
-                        }
-                    }
-                    // SCROLL CURSORS - hep default olsun, all-scroll görünmesin
-                    else if ([elementRole isEqualToString:@"AXScrollBar"]) {
-                        cursorType = @"default"; // ScrollBar'lar için de default
-                    }
-                    // AXScrollArea - hep default
-                    else if ([elementRole isEqualToString:@"AXScrollArea"]) {
-                        cursorType = @"default"; // ScrollArea her zaman default
-                    }
-                    // CROSSHAIR CURSORS (drawing/selection tools)
-                    else if ([elementRole isEqualToString:@"AXCanvas"] ||
-                             [elementRole isEqualToString:@"AXDrawingArea"]) {
-                        cursorType = @"crosshair";
-                    }
-                    // ZOOM CURSORS (zoom controls)
-                    else if ([elementRole isEqualToString:@"AXZoomButton"]) {
-                        cursorType = @"zoom-in";
-                    }
-                    // NOT-ALLOWED CURSORS (disabled elements)
-                    else if ([elementRole isEqualToString:@"AXStaticText"] ||
-                             [elementRole isEqualToString:@"AXGroup"]) {
-                        // Check if element is disabled/readonly
-                        CFBooleanRef enabled = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, kAXEnabledAttribute, (CFTypeRef*)&enabled);
-                        if (error == kAXErrorSuccess && enabled && !CFBooleanGetValue(enabled)) {
-                            cursorType = @"not-allowed";
-                        }
-                    }
-                    // WINDOW BORDER RESIZE - sadece pencere kenarlarında
-                    else if ([elementRole isEqualToString:@"AXWindow"]) {
-                        // Check window attributes to see if it's resizable
-                        CFBooleanRef resizable = NULL;
-                        AXError resizableError = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXResizeButton"), (CFTypeRef*)&resizable);
-
-                        // Sadece resize edilebilir pencereler için cursor değişimi
-                        if (resizableError == kAXErrorSuccess || true) { // AXResizeButton bulunamazsa da devam et
-                            CFTypeRef position = NULL;
-                            CFTypeRef size = NULL;
-                            error = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
-                            AXError sizeError = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
-
-                            if (error == kAXErrorSuccess && sizeError == kAXErrorSuccess && position && size) {
-                                CGPoint windowPos;
-                                CGSize windowSize;
-                                AXValueGetValue((AXValueRef)position, kAXValueTypeCGPoint, &windowPos);
-                                AXValueGetValue((AXValueRef)size, kAXValueTypeCGSize, &windowSize);
-
-                                CGFloat x = cursorPos.x - windowPos.x;
-                                CGFloat y = cursorPos.y - windowPos.y;
-                                CGFloat w = windowSize.width;
-                                CGFloat h = windowSize.height;
-                                CGFloat edge = 3.0; // Daha küçük edge detection (3px)
-
-                                // Sadece çok kenar köşelerde resize cursor'ı göster
-                                BOOL isOnBorder = NO;
-
-                                // Corner resize detection - çok dar alanda, doğru açılar
-                                if (x <= edge && y <= edge) {
-                                    cursorType = @"nwse-resize"; // Sol üst köşe - northwest-southeast
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y <= edge) {
-                                    cursorType = @"nesw-resize"; // Sağ üst köşe - northeast-southwest
-                                    isOnBorder = YES;
-                                }
-                                else if (x <= edge && y >= h-edge) {
-                                    cursorType = @"nesw-resize"; // Sol alt köşe - southwest-northeast
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y >= h-edge) {
-                                    cursorType = @"nwse-resize"; // Sağ alt köşe - southeast-northwest
-                                    isOnBorder = YES;
-                                }
-                                // Edge resize detection - sadece çok kenarlarda
-                                else if (x <= edge && y > edge && y < h-edge) {
-                                    cursorType = @"col-resize"; // Sol kenar - column resize (yatay)
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y > edge && y < h-edge) {
-                                    cursorType = @"col-resize"; // Sağ kenar - column resize (yatay)
-                                    isOnBorder = YES;
-                                }
-                                else if (y <= edge && x > edge && x < w-edge) {
-                                    cursorType = @"ns-resize"; // Üst kenar - north-south resize (dikey)
-                                    isOnBorder = YES;
-                                }
-                                else if (y >= h-edge && x > edge && x < w-edge) {
-                                    cursorType = @"ns-resize"; // Alt kenar - north-south resize (dikey)
-                                    isOnBorder = YES;
-                                }
-
-                                // Eğer border'da değilse default
-                                if (!isOnBorder) {
-                                    cursorType = @"default";
-                                }
-
-                                if (position) CFRelease(position);
-                                if (size) CFRelease(size);
-                            } else {
-                                cursorType = @"default";
-                            }
-                        } else {
-                            cursorType = @"default";
-                        }
-                    }
-                    // HER DURUM İÇİN DEFAULT FALLBACK
-                    else {
-                        // Bilinmeyen elementler için her zaman default
-                        cursorType = @"default";
-                    }
+        NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
 
-                    // Check subroles for additional context
-                    CFStringRef subrole = NULL;
-                    error = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
-                    if (error == kAXErrorSuccess && subrole) {
-                        NSString *elementSubrole = (__bridge_transfer NSString*)subrole;
-                        NSLog(@"🎯 ELEMENT SUBROLE: %@", elementSubrole);
-
-                        // Subrole override'ları - sadece çok spesifik durumlar için
-                        if ([elementSubrole isEqualToString:@"AXCloseButton"] ||
-                            [elementSubrole isEqualToString:@"AXMinimizeButton"] ||
-                            [elementSubrole isEqualToString:@"AXZoomButton"] ||
-                            [elementSubrole isEqualToString:@"AXToolbarButton"]) {
-                            cursorType = @"pointer";
-                        }
-                        // Copy/alias subroles - sadece bu durumlar için override
-                        else if ([elementSubrole isEqualToString:@"AXFileDrop"] ||
-                                 [elementSubrole isEqualToString:@"AXDropTarget"]) {
-                            cursorType = @"copy";
-                        }
-                        // Alias/shortcut subroles
-                        else if ([elementSubrole isEqualToString:@"AXAlias"] ||
-                                 [elementSubrole isEqualToString:@"AXShortcut"]) {
-                            cursorType = @"alias";
-                        }
-                        // Grabbing state (being dragged) - sadece gerçek drag sırasında
-                        else if ([elementSubrole isEqualToString:@"AXDragging"] ||
-                                 [elementSubrole isEqualToString:@"AXMoving"]) {
-                            cursorType = @"grabbing";
+        @try {
+            // Layer 1: Fast NSCursor detection (most reliable)
+            NSString *nsCursorType = detectCursorTypeFromNSCursor();
+
+            // Layer 2: Accessibility API for context (when NSCursor isn't enough)
+            NSString *contextualCursorType = nsCursorType;
+
+            // Only use expensive Accessibility API if NSCursor gives us "default"
+            if ([nsCursorType isEqualToString:@"default"]) {
+                CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
+                AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+                AXUIElementRef elementAtPosition = NULL;
+                AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+
+                if (error == kAXErrorSuccess && elementAtPosition) {
+                    CFStringRef role = NULL;
+                    error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
+
+                    if (error == kAXErrorSuccess && role) {
+                        NSString *elementRole = (__bridge_transfer NSString*)role;
+
+                        // Simplified, high-confidence role mappings only
+                        if ([elementRole isEqualToString:@"AXTextField"] ||
+                            [elementRole isEqualToString:@"AXTextArea"] ||
+                            [elementRole isEqualToString:@"AXSearchField"]) {
+                            contextualCursorType = @"text";
                         }
-                        // Zoom controls - sadece spesifik zoom butonları için
-                        else if ([elementSubrole isEqualToString:@"AXZoomIn"]) {
-                            cursorType = @"zoom-in";
+                        else if ([elementRole isEqualToString:@"AXLink"] ||
+                                 [elementRole isEqualToString:@"AXButton"] ||
+                                 [elementRole isEqualToString:@"AXMenuItem"]) {
+                            contextualCursorType = @"pointer";
                         }
-                        else if ([elementSubrole isEqualToString:@"AXZoomOut"]) {
-                            cursorType = @"zoom-out";
+                        else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
+                            contextualCursorType = @"progress";
                         }
-                        // Subrole'dan bir şey bulamazsa role-based cursor'ı koruyoruz
                     }
+                    CFRelease(elementAtPosition);
                 }
+                if (systemWide) CFRelease(systemWide);
+            }
 
-                CFRelease(elementAtPosition);
+            // Layer 3: Stability filtering to prevent oscillation
+            NSString *detectedCursorType = contextualCursorType;
+
+            // Time-based stability check
+            if (currentTime - g_lastCursorCheckTime > CURSOR_STABILITY_THRESHOLD) {
+                // Enough time has passed, reset counters
+                g_sameCursorDetectionCount = 0;
+                g_pendingCursorType = detectedCursorType;
             }
 
-            if (systemWide) {
-                CFRelease(systemWide);
+            // Check if detected cursor matches pending cursor
+            if ([detectedCursorType isEqualToString:g_pendingCursorType]) {
+                g_sameCursorDetectionCount++;
+
+                // If we have enough confirmations, update stable cursor
+                if (g_sameCursorDetectionCount >= CURSOR_CONFIRMATION_COUNT) {
+                    g_stableCursorType = detectedCursorType;
+                    g_lastDetectedCursorType = detectedCursorType;
+                }
+            } else {
+                // Different cursor detected, start new pending
+                g_pendingCursorType = detectedCursorType;
+                g_sameCursorDetectionCount = 1;
             }
 
-            // Son güvence - eğer cursorType hala nil veya geçersizse default'a çevir
-            if (!cursorType || [cursorType length] == 0) {
-                cursorType = @"default";
+            g_lastCursorCheckTime = currentTime;
+
+            // Final validation
+            NSString *finalCursorType = g_stableCursorType;
+            if (!finalCursorType || [finalCursorType length] == 0) {
+                finalCursorType = @"default";
             }
 
-            NSLog(@"🎯 FINAL CURSOR TYPE: %@", cursorType);
-            return cursorType;
-            
+            // Debug logging for stability tracking
+            NSLog(@"🎯 CURSOR DETECTION - NSCursor: %@, Contextual: %@, Stable: %@, Count: %d",
+                  nsCursorType, contextualCursorType, finalCursorType, g_sameCursorDetectionCount);
+
+            return finalCursorType;
+
         } @catch (NSException *exception) {
             NSLog(@"Error in getCursorType: %@", exception);
-            return @"default";
+            return g_stableCursorType ?: @"default";
         }
     }
 }
@@ -501,7 +399,11 @@ void cleanupCursorTracking() {
     g_outputPath = nil;
     g_debugCallbackCount = 0;
     g_lastDetectedCursorType = nil;
+    g_stableCursorType = @"default";
     g_cursorTypeCounter = 0;
+    g_lastCursorCheckTime = 0;
+    g_sameCursorDetectionCount = 0;
+    g_pendingCursorType = nil;
     g_isFirstWrite = true;
 }
 

package/src/mac_recorder.mm

@@ -4,7 +4,6 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <ImageIO/ImageIO.h>
 #import <CoreAudio/CoreAudio.h>
-#include <cstring>
 
 // Import screen capture (ScreenCaptureKit only)
 #import "screen_capture_kit.h"
@@ -60,69 +59,6 @@ void cleanupRecording() {
     g_isRecording = false;
 }
 
-static Napi::Value NSObjectToNapiValue(Napi::Env env, id value) {
-    if (!value || value == [NSNull null]) {
-        return env.Null();
-    }
-
-    if ([value isKindOfClass:[NSDictionary class]]) {
-        NSDictionary *dict = (NSDictionary *)value;
-        Napi::Object obj = Napi::Object::New(env);
-
-        for (id key in dict) {
-            id nestedValue = [dict objectForKey:key];
-            NSString *keyString = nil;
-            if ([key isKindOfClass:[NSString class]]) {
-                keyString = (NSString *)key;
-            } else {
-                keyString = [key description];
-            }
-
-            if (!keyString) {
-                continue;
-            }
-
-            obj.Set(Napi::String::New(env, [keyString UTF8String]), NSObjectToNapiValue(env, nestedValue));
-        }
-
-        return obj;
-    }
-
-    if ([value isKindOfClass:[NSArray class]]) {
-        NSArray *array = (NSArray *)value;
-        Napi::Array result = Napi::Array::New(env, array.count);
-
-        for (NSUInteger i = 0; i < array.count; i++) {
-            result.Set(i, NSObjectToNapiValue(env, array[i]));
-        }
-
-        return result;
-    }
-
-    if ([value isKindOfClass:[NSNumber class]]) {
-        NSNumber *number = (NSNumber *)value;
-        const char *type = [number objCType];
-
-        if (strcmp(type, @encode(BOOL)) == 0) {
-            return Napi::Boolean::New(env, [number boolValue]);
-        }
-
-        return Napi::Number::New(env, [number doubleValue]);
-    }
-
-    if ([value isKindOfClass:[NSString class]]) {
-        NSString *stringValue = (NSString *)value;
-        return Napi::String::New(env, [stringValue UTF8String]);
-    }
-
-    if ([value isKindOfClass:[NSDate class]]) {
-        NSDate *dateValue = (NSDate *)value;
-        return Napi::Number::New(env, [dateValue timeIntervalSince1970] * 1000.0);
-    }
-
-    return Napi::String::New(env, [[value description] UTF8String]);
-}
-
 // NAPI Function: Start Recording
 Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -146,7 +82,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     // Options parsing
     CGRect captureRect = CGRectNull;
-    bool captureCursor = false; // Default: cursor hidden in video
+    bool captureCursor = false; // Default olarak cursor gizli
     bool includeMicrophone = false; // Default olarak mikrofon kapalı
     bool includeSystemAudio = true; // Default olarak sistem sesi açık
     CGDirectDisplayID displayID = CGMainDisplayID(); // Default ana ekran
@@ -269,12 +205,14 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             NSLog(@"🔧 FORCE_AVFOUNDATION environment variable detected - skipping ScreenCaptureKit");
         }
         
-        // Try ScreenCaptureKit on macOS 14+ (Electron supported) with robust fallback
-        if (isM14Plus && !forceAVFoundation) {
+        // Electron-first priority: This application is built for Electron.js
+        // macOS 15+ → ScreenCaptureKit (including Electron)
+        // macOS 14/13 → AVFoundation (including Electron)
+        if (isM15Plus && !forceAVFoundation) {
             if (isElectron) {
-                NSLog(@"⚡ ELECTRON PRIORITY: macOS 14+ Electron → ScreenCaptureKit with full support (fallbacks enabled)");
+                NSLog(@"⚡ ELECTRON PRIORITY: macOS 15+ Electron → ScreenCaptureKit with full support");
             } else {
-                NSLog(@"✅ macOS 14+ Node.js → ScreenCaptureKit available with full compatibility");
+                NSLog(@"✅ macOS 15+ Node.js → ScreenCaptureKit available with full compatibility");
             }
             
             // Try ScreenCaptureKit with extensive safety measures
@@ -349,14 +287,18 @@ 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");
         } else {
-            // macOS 13 or forced AVFoundation → use AVFoundation (Electron supported!)
+            // macOS 14/13 or forced AVFoundation → ALWAYS use AVFoundation (Electron supported!)
             if (isElectron) {
-                if (isM13Plus) {
+                if (isM14Plus) {
+                    NSLog(@"⚡ ELECTRON PRIORITY: macOS 14/13 Electron → AVFoundation with full support");
+                } else if (isM13Plus) {
                     NSLog(@"⚡ ELECTRON PRIORITY: macOS 13 Electron → AVFoundation with limited features");
                 }
             } else {
-                if (isM14Plus) {
-                    NSLog(@"🎯 macOS 14+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
+                if (isM15Plus) {
+                    NSLog(@"🎯 macOS 15+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
+                } else if (isM14Plus) {
+                    NSLog(@"🎯 macOS 14 Node.js → using AVFoundation (primary method)");
                 } else if (isM13Plus) {
                     NSLog(@"🎯 macOS 13 Node.js → using AVFoundation (limited features)");  
                 }
@@ -633,29 +575,19 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
         
         for (uint32_t i = 0; i < displayCount; i++) {
             CGDirectDisplayID displayID = activeDisplays[i];
-        CGRect displayBounds = CGDisplayBounds(displayID);
-        bool isPrimary = (displayID == CGMainDisplayID());
-        size_t pixelWidth = CGDisplayPixelsWide(displayID);
-        size_t pixelHeight = CGDisplayPixelsHigh(displayID);
-        double logicalWidth = displayBounds.size.width;
-        double logicalHeight = displayBounds.size.height;
-        double scaleX = (logicalWidth > 0.0) ? ((double)pixelWidth / logicalWidth) : 1.0;
-        double scaleY = (logicalHeight > 0.0) ? ((double)pixelHeight / logicalHeight) : 1.0;
-
-        NSDictionary *displayInfo = @{
-            @"id": @(displayID),  // Direct CGDirectDisplayID
-            @"name": [NSString stringWithFormat:@"Display %u", (unsigned int)(i + 1)],
-            @"width": @((int)displayBounds.size.width),
-            @"height": @((int)displayBounds.size.height),
-            @"x": @((int)displayBounds.origin.x),
-            @"y": @((int)displayBounds.origin.y),
-            @"isPrimary": @(isPrimary),
-            @"pixelWidth": @((int)pixelWidth),
-            @"pixelHeight": @((int)pixelHeight),
-            @"scaleX": @((double)scaleX),
-            @"scaleY": @((double)scaleY)
-        };
-        [displays addObject:displayInfo];
+            CGRect displayBounds = CGDisplayBounds(displayID);
+            bool isPrimary = (displayID == CGMainDisplayID());
+            
+            NSDictionary *displayInfo = @{
+                @"id": @(displayID),  // Direct CGDirectDisplayID
+                @"name": [NSString stringWithFormat:@"Display %u", (unsigned int)(i + 1)],
+                @"width": @((int)displayBounds.size.width),
+                @"height": @((int)displayBounds.size.height),
+                @"x": @((int)displayBounds.origin.x),
+                @"y": @((int)displayBounds.origin.y),
+                @"isPrimary": @(isPrimary)
+            };
+            [displays addObject:displayInfo];
         }
         Napi::Array result = Napi::Array::New(env, displays.count);
         
@@ -710,21 +642,6 @@ Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(env, isRecording);
 }
 
-Napi::Value GetActiveCaptureInfo(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-
-    if (@available(macOS 15.0, *)) {
-        NSDictionary *captureInfo = [ScreenCaptureKitRecorder currentCaptureInfo];
-        if (!captureInfo || captureInfo.count == 0) {
-            return env.Null();
-        }
-
-        return NSObjectToNapiValue(env, captureInfo);
-    }
-
-    return env.Null();
-}
-
 // NAPI Function: Get Window Thumbnail
 Napi::Value GetWindowThumbnail(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -1065,7 +982,6 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "getDisplays"), Napi::Function::New(env, GetDisplays));
     exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, GetWindows));
     exports.Set(Napi::String::New(env, "getRecordingStatus"), Napi::Function::New(env, GetRecordingStatus));
-    exports.Set(Napi::String::New(env, "getActiveCaptureInfo"), Napi::Function::New(env, GetActiveCaptureInfo));
     exports.Set(Napi::String::New(env, "checkPermissions"), Napi::Function::New(env, CheckPermissions));
     
     // Thumbnail functions
@@ -1081,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.h

@@ -15,6 +15,5 @@ API_AVAILABLE(macos(15.0))
 + (void)finalizeRecording;
 + (void)finalizeVideoWriter;
 + (void)cleanupVideoWriter;
-+ (NSDictionary *)currentCaptureInfo;
 
-@end
+@end

package/src/screen_capture_kit.mm

@@ -7,7 +7,6 @@ static id<SCStreamDelegate> API_AVAILABLE(macos(12.3)) g_streamDelegate = nil;
 static BOOL g_isRecording = NO;
 static BOOL g_isCleaningUp = NO;  // Prevent recursive cleanup
 static NSString *g_outputPath = nil;
-static NSDictionary *g_currentCaptureInfo = nil;
 
 @interface PureScreenCaptureDelegate : NSObject <SCStreamDelegate>
 @end
@@ -59,8 +58,6 @@ static NSDictionary *g_currentCaptureInfo = nil;
         g_isCleaningUp = NO;
     }
     
-    g_currentCaptureInfo = nil;
-
     NSString *outputPath = config[@"outputPath"];
     if (!outputPath || [outputPath length] == 0) {
         NSLog(@"❌ Invalid output path provided");
@@ -127,34 +124,6 @@ static NSDictionary *g_currentCaptureInfo = nil;
                 filter = [[SCContentFilter alloc] initWithDesktopIndependentWindow:targetWindow];
                 recordingWidth = (NSInteger)targetWindow.frame.size.width;
                 recordingHeight = (NSInteger)targetWindow.frame.size.height;
-
-                CGRect windowFrame = targetWindow.frame;
-                NSDictionary *frameDict = @{
-                    @"x": @(windowFrame.origin.x),
-                    @"y": @(windowFrame.origin.y),
-                    @"width": @(windowFrame.size.width),
-                    @"height": @(windowFrame.size.height)
-                };
-
-                NSMutableDictionary *windowInfo = [@{
-                    @"id": @(targetWindow.windowID),
-                    @"frame": frameDict
-                } mutableCopy];
-
-                if (targetWindow.title) {
-                    windowInfo[@"title"] = targetWindow.title;
-                }
-                if (targetApp && targetApp.applicationName) {
-                    windowInfo[@"appName"] = targetApp.applicationName;
-                }
-                if (targetApp && targetApp.bundleIdentifier) {
-                    windowInfo[@"bundleId"] = targetApp.bundleIdentifier;
-                }
-
-                g_currentCaptureInfo = @{
-                    @"type": @"window",
-                    @"window": windowInfo
-                };
             } else {
                 NSLog(@"❌ Window ID %@ not found", windowId);
                 return;
@@ -194,24 +163,6 @@ static NSDictionary *g_currentCaptureInfo = nil;
             filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:@[]];
             recordingWidth = targetDisplay.width;
             recordingHeight = targetDisplay.height;
-
-            CGRect displayFrame = targetDisplay.frame;
-            NSDictionary *displayFrameDict = @{
-                @"x": @(displayFrame.origin.x),
-                @"y": @(displayFrame.origin.y),
-                @"width": @(displayFrame.size.width),
-                @"height": @(displayFrame.size.height)
-            };
-
-            g_currentCaptureInfo = @{
-                @"type": @"display",
-                @"display": @{
-                    @"id": @(targetDisplay.displayID),
-                    @"frame": displayFrameDict,
-                    @"width": @(targetDisplay.width),
-                    @"height": @(targetDisplay.height)
-                }
-            };
         }
         
         // CROP AREA SUPPORT - Adjust dimensions and source rect
@@ -442,8 +393,7 @@ static NSDictionary *g_currentCaptureInfo = nil;
             // SCRecordingOutput finalizes automatically
             NSLog(@"✅ Pure recording output finalized");
         }
-
-        g_currentCaptureInfo = nil;
+        
         [ScreenCaptureKitRecorder cleanupVideoWriter];
     }
 }
@@ -481,10 +431,4 @@ static NSDictionary *g_currentCaptureInfo = nil;
     }
 }
 
-+ (NSDictionary *)currentCaptureInfo {
-    @synchronized([ScreenCaptureKitRecorder class]) {
-        return g_currentCaptureInfo;
-    }
-}
-
-@end
+@end