node-mac-recorder 2.17.8 → 2.17.10

package/index.js

@@ -31,6 +31,8 @@ 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;
@@ -41,7 +43,7 @@ class MacRecorder extends EventEmitter {
 			quality: "medium",
 			frameRate: 30,
 			captureArea: null, // { x, y, width, height }
-			captureCursor: false, // Default olarak cursor gizli
+			captureCursor: false, // Default: cursor hidden in video
 			showClicks: false,
 			displayId: null, // Hangi ekranı kaydedeceği (null = ana ekran)
 			windowId: null, // Hangi pencereyi kaydedeceği (null = tam ekran)
@@ -79,16 +81,29 @@ class MacRecorder extends EventEmitter {
 	 */
 	async getDisplays() {
 		const displays = nativeBinding.getDisplays();
-		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}`,
-		}));
+		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}`,
+			};
+		});
 	}
 
 	/**
@@ -252,16 +267,29 @@ class MacRecorder extends EventEmitter {
 
 						// Recording için display bilgisini sakla (cursor capture için)
 						const targetDisplay = displays.find(d => d.id === targetDisplayId);
-						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]),
-						};
+						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.options.captureArea = {
@@ -289,15 +317,26 @@ 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: parseInt(targetDisplay.resolution.split("x")[0]),
-						height: parseInt(targetDisplay.resolution.split("x")[1]),
+						width: logicalWidth,
+						height: logicalHeight,
+						pixelWidth,
+						pixelHeight,
+						scaleX,
+						scaleY,
 						// Add scaling information for cursor coordinate transformation
-						logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
-						logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
+						logicalWidth,
+						logicalHeight,
 					};
 				}
 			} catch (error) {
@@ -356,63 +395,108 @@ class MacRecorder extends EventEmitter {
 					this.isRecording = true;
 					this.recordingStartTime = Date.now();
 
-					// Start cursor tracking automatically with recording
-					let cursorOptions = {};
-
-					// For window recording, use the original window coordinates (not display-relative captureArea)
-					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) {
-								// Restart cursor capture with correct window coordinates
-								if (this.cursorCaptureInterval) {
-									this.stopCursorCapture().then(() => {
-										this.startCursorCapture(cursorFilePath, {
-											windowRelative: true,
-											windowInfo: {
-												x: targetWindow.x,  // Global window X coordinate
-												y: targetWindow.y,  // Global window Y coordinate
-												width: targetWindow.width,
-												height: targetWindow.height,
-												displayId: this.options.displayId,
-												originalWindow: targetWindow,
-												captureArea: this.options.captureArea
-											}
-										}).catch(cursorError => {
-											console.warn('Cursor tracking failed to restart:', cursorError.message);
-										});
-									}).catch(stopError => {
-										console.warn('Failed to stop cursor capture:', stopError.message);
-									});
-								} else {
+						// 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);
+										}
+									}
+
+									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: targetWindow.x,  // Global window X coordinate
-											y: targetWindow.y,  // Global window Y coordinate
-											width: targetWindow.width,
-											height: targetWindow.height,
+											x: globalWindowX,
+											y: globalWindowY,
+											width: windowWidth,
+											height: windowHeight,
 											displayId: this.options.displayId,
+											captureArea: captureAreaForCursor,
 											originalWindow: targetWindow,
-											captureArea: this.options.captureArea
+											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(error => {
-							console.warn('Could not get window info for cursor tracking:', error.message);
-							// Fallback to basic cursor tracking
-							this.startCursorCapture(cursorFilePath, cursorOptions).catch(cursorError => {
-								console.warn('Cursor tracking failed to start:', cursorError.message);
-							});
-						});
-					} else {
-						// For display recording, use basic cursor tracking
-						this.startCursorCapture(cursorFilePath, cursorOptions).catch(cursorError => {
-							console.warn('Cursor tracking failed to start:', cursorError.message);
+							};
+
+							startWindowCursorTracking();
+						} 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);
 						});
 					}
 
@@ -717,46 +801,157 @@ class MacRecorder extends EventEmitter {
 
 		// Koordinat sistemi belirle: window-relative, display-relative veya global
 		if (options.windowRelative && options.windowInfo) {
-			// Window recording için display'e relative captureArea koordinatlarını kullan
-			const captureArea = options.windowInfo.captureArea;
-			if (captureArea) {
-				// captureArea zaten display-relative koordinatlar
-				this.cursorDisplayInfo = {
-					displayId: options.windowInfo.displayId || null,
-					x: captureArea.x,  // Display-relative X
-					y: captureArea.y,  // Display-relative Y
-					width: captureArea.width,
-					height: captureArea.height,
-					windowRelative: true,
-					windowInfo: options.windowInfo
-				};
-			} else {
-				// Fallback: orijinal window koordinatları
-				this.cursorDisplayInfo = {
-					displayId: options.windowInfo.displayId || null,
-					x: options.windowInfo.x || 0,
-					y: options.windowInfo.y || 0,
-					width: options.windowInfo.width,
-					height: options.windowInfo.height,
-					windowRelative: true,
-					windowInfo: options.windowInfo
-				};
+			const windowInfo = options.windowInfo;
+			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;
+
+			if (captureArea && targetDisplay) {
+				if (!hasNumber(globalX) && hasNumber(captureArea.x) && hasNumber(targetDisplay.x)) {
+					globalX = targetDisplay.x + captureArea.x;
+				}
+				if (!hasNumber(globalY) && hasNumber(captureArea.y) && hasNumber(targetDisplay.y)) {
+					globalY = targetDisplay.y + captureArea.y;
+				}
 			}
+
+			if (!hasNumber(globalX)) {
+				if (captureArea && hasNumber(captureArea.x) && targetDisplay && hasNumber(targetDisplay.x)) {
+					globalX = targetDisplay.x + captureArea.x;
+				} else {
+					globalX = hasNumber(captureArea?.x) ? captureArea.x : 0;
+				}
+			}
+
+			if (!hasNumber(globalY)) {
+				if (captureArea && hasNumber(captureArea.y) && targetDisplay && hasNumber(targetDisplay.y)) {
+					globalY = targetDisplay.y + captureArea.y;
+				} else {
+					globalY = hasNumber(captureArea?.y) ? captureArea.y : 0;
+				}
+			}
+
+			const displayOffsetX = captureArea && hasNumber(captureArea.x)
+				? captureArea.x
+				: (targetDisplay && hasNumber(globalX) && hasNumber(targetDisplay.x)
+					? globalX - targetDisplay.x
+					: globalX ?? 0);
+			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;
+			}
+
+			this.cursorDisplayInfo = {
+				displayId:
+					windowInfo.displayId ??
+					targetDisplay?.displayId ??
+					targetDisplay?.id ??
+					null,
+				x: globalX,
+				y: globalY,
+				width: windowInfo.width,
+				height: windowInfo.height,
+				pixelWidth: windowPixelWidth,
+				pixelHeight: windowPixelHeight,
+				scaleX: displayScaleX,
+				scaleY: displayScaleY,
+				displayRelativeX: displayOffsetX,
+				displayRelativeY: displayOffsetY,
+				windowRelative: true,
+				windowInfo: {
+					...enrichedWindowInfo
+				},
+				targetDisplay,
+				captureArea: captureAreaInfo
+			};
+		} 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) {
-			// Recording başlatılmışsa o display'i kullan
+			// Fallback: Use recording display info if available
 			this.cursorDisplayInfo = this.recordingDisplayInfo;
 		} else {
-			// Main display bilgisini al (her zaman relative koordinatlar için)
+			// Final fallback: Main display global coordinates
 			try {
 				const displays = await this.getDisplays();
 				const mainDisplay = displays.find((d) => d.isPrimary) || displays[0];
 				if (mainDisplay) {
 					this.cursorDisplayInfo = {
-						displayId: 0,
+						displayId: mainDisplay.id,
 						x: mainDisplay.x,
 						y: mainDisplay.y,
-						width: parseInt(mainDisplay.resolution.split("x")[0]),
-						height: parseInt(mainDisplay.resolution.split("x")[1]),
+						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),
 					};
 				}
 			} catch (error) {
@@ -772,86 +967,130 @@ class MacRecorder extends EventEmitter {
 				fs.writeFileSync(filepath, "[");
 
 				this.cursorCaptureFile = filepath;
-				this.cursorCaptureStartTime = Date.now();
+				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.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 timestamp = Date.now() - this.cursorCaptureStartTime;
+						const captureTimestamp = this.cursorCaptureStartTime ? now - this.cursorCaptureStartTime : 0;
+						const recordingBase = this.cursorRecordingBaseTime || this.cursorCaptureStartTime || now;
+						const recordingTimestamp = Math.max(0, now - recordingBase);
 
-						// Global koordinatları relative koordinatlara çevir
+						// Transform coordinates based on recording type
 						let x = position.x;
 						let y = position.y;
 						let coordinateSystem = "global";
 
 						if (this.cursorDisplayInfo) {
 							if (this.cursorDisplayInfo.windowRelative) {
-								// Window recording: cursor'ı önce target display'e relative yap, sonra captureArea'ya relative yap
-								const targetDisplay = this.recordingDisplayInfo;
-								if (targetDisplay) {
-									// 1. Global -> Display-relative
+								// 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;
-
-									// 2. Display-relative -> CaptureArea-relative (window-relative)
-									x = displayRelativeX - this.cursorDisplayInfo.x;
-									y = displayRelativeY - this.cursorDisplayInfo.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: doğrudan offset çıkar
+									// Fallback: global offsets
 									x = position.x - this.cursorDisplayInfo.x;
 									y = position.y - this.cursorDisplayInfo.y;
 								}
-							} else {
-								// Display recording: doğrudan offset çıkar
+								coordinateSystem = "window-relative";
+
+								// Window bounds check - skip if cursor is outside window
+								if (x < 0 || y < 0 || x >= this.cursorDisplayInfo.width || y >= this.cursorDisplayInfo.height) {
+									return; // Skip frame - cursor outside window
+								}
+							} else if (this.cursorDisplayInfo.displayRelative) {
+								// Display recording: Transform global → display-relative coordinates
 								x = position.x - this.cursorDisplayInfo.x;
 								y = position.y - this.cursorDisplayInfo.y;
-							}
+								coordinateSystem = "display-relative";
 
-							if (this.cursorDisplayInfo.windowRelative) {
-								// Window-relative koordinatlar
-								coordinateSystem = "window-relative";
-								
-								// Window bounds kontrolü - cursor window dışındaysa kaydetme
-								if (
-									x < 0 ||
-									y < 0 ||
-									x >= this.cursorDisplayInfo.width ||
-									y >= this.cursorDisplayInfo.height
-								) {
-									return; // Bu frame'i skip et - cursor pencere dışında
+								// Display bounds check - skip if cursor is outside display
+								if (x < 0 || y < 0 || x >= this.cursorDisplayInfo.width || y >= this.cursorDisplayInfo.height) {
+									return; // Skip frame - cursor outside display
 								}
 							} else {
-								// Display-relative koordinatlar
+								// Legacy fallback: Use global coordinates with basic offset
+								x = position.x - this.cursorDisplayInfo.x;
+								y = position.y - this.cursorDisplayInfo.y;
 								coordinateSystem = "display-relative";
-								
-								// Display bounds kontrolü
-								if (
-									x < 0 ||
-									y < 0 ||
-									x >= this.cursorDisplayInfo.width ||
-									y >= this.cursorDisplayInfo.height
-								) {
-									return; // Bu frame'i skip et - cursor display dışında
-								}
 							}
 						}
 
+						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: x,
-							y: y,
-							timestamp: timestamp,
-							unixTimeMs: Date.now(),
+							x: logicalX,
+							y: logicalY,
+							pixelX,
+							pixelY,
+							scaleX,
+							scaleY,
+							timestamp: recordingTimestamp,
+							captureTimestamp,
+							recordingOffsetMs: this.cursorRecordingOffsetMs,
+							unixTimeMs: now,
 							cursorType: position.cursorType,
 							type: position.eventType || "move",
 							coordinateSystem: coordinateSystem,
+							// Include recording context for window-relative coordinates
 							...(this.cursorDisplayInfo?.windowRelative && {
 								windowInfo: {
 									width: this.cursorDisplayInfo.width,
 									height: this.cursorDisplayInfo.height,
-									originalWindow: this.cursorDisplayInfo.windowInfo
+									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
+								}
+							}),
+							// Include display context for display-relative coordinates
+							...(this.cursorDisplayInfo?.displayRelative && {
+								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
 								}
 							})
 						};
@@ -910,6 +1149,8 @@ class MacRecorder extends EventEmitter {
 				this.cursorCaptureStartTime = null;
 				this.cursorCaptureFirstWrite = true;
 				this.cursorDisplayInfo = null;
+				this.cursorRecordingBaseTime = null;
+				this.cursorRecordingOffsetMs = 0;
 
 				this.emit("cursorCaptureStopped");
 				resolve(true);
@@ -1035,6 +1276,8 @@ 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.8",
+	"version": "2.17.10",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/mac_recorder.mm

@@ -4,6 +4,7 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <ImageIO/ImageIO.h>
 #import <CoreAudio/CoreAudio.h>
+#include <cstring>
 
 // Import screen capture (ScreenCaptureKit only)
 #import "screen_capture_kit.h"
@@ -59,6 +60,69 @@ 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();
@@ -82,7 +146,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     // Options parsing
     CGRect captureRect = CGRectNull;
-    bool captureCursor = false; // Default olarak cursor gizli
+    bool captureCursor = false; // Default: cursor hidden in video
     bool includeMicrophone = false; // Default olarak mikrofon kapalı
     bool includeSystemAudio = true; // Default olarak sistem sesi açık
     CGDirectDisplayID displayID = CGMainDisplayID(); // Default ana ekran
@@ -205,14 +269,12 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             NSLog(@"🔧 FORCE_AVFOUNDATION environment variable detected - skipping ScreenCaptureKit");
         }
         
-        // Electron-first priority: This application is built for Electron.js
-        // macOS 15+ → ScreenCaptureKit (including Electron)
-        // macOS 14/13 → AVFoundation (including Electron)
-        if (isM15Plus && !forceAVFoundation) {
+        // Try ScreenCaptureKit on macOS 14+ (Electron supported) with robust fallback
+        if (isM14Plus && !forceAVFoundation) {
             if (isElectron) {
-                NSLog(@"⚡ ELECTRON PRIORITY: macOS 15+ Electron → ScreenCaptureKit with full support");
+                NSLog(@"⚡ ELECTRON PRIORITY: macOS 14+ Electron → ScreenCaptureKit with full support (fallbacks enabled)");
             } else {
-                NSLog(@"✅ macOS 15+ Node.js → ScreenCaptureKit available with full compatibility");
+                NSLog(@"✅ macOS 14+ Node.js → ScreenCaptureKit available with full compatibility");
             }
             
             // Try ScreenCaptureKit with extensive safety measures
@@ -287,18 +349,14 @@ 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 14/13 or forced AVFoundation → ALWAYS use AVFoundation (Electron supported!)
+            // macOS 13 or forced AVFoundation → use AVFoundation (Electron supported!)
             if (isElectron) {
-                if (isM14Plus) {
-                    NSLog(@"⚡ ELECTRON PRIORITY: macOS 14/13 Electron → AVFoundation with full support");
-                } else if (isM13Plus) {
+                if (isM13Plus) {
                     NSLog(@"⚡ ELECTRON PRIORITY: macOS 13 Electron → AVFoundation with limited features");
                 }
             } else {
-                if (isM15Plus) {
-                    NSLog(@"🎯 macOS 15+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
-                } else if (isM14Plus) {
-                    NSLog(@"🎯 macOS 14 Node.js → using AVFoundation (primary method)");
+                if (isM14Plus) {
+                    NSLog(@"🎯 macOS 14+ Node.js with FORCE_AVFOUNDATION → using AVFoundation");
                 } else if (isM13Plus) {
                     NSLog(@"🎯 macOS 13 Node.js → using AVFoundation (limited features)");  
                 }
@@ -575,19 +633,29 @@ 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());
-            
-            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];
+        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];
         }
         Napi::Array result = Napi::Array::New(env, displays.count);
         
@@ -642,6 +710,21 @@ 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();
@@ -982,6 +1065,7 @@ 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
@@ -997,4 +1081,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,5 +15,6 @@ API_AVAILABLE(macos(15.0))
 + (void)finalizeRecording;
 + (void)finalizeVideoWriter;
 + (void)cleanupVideoWriter;
++ (NSDictionary *)currentCaptureInfo;
 
-@end
+@end

package/src/screen_capture_kit.mm

@@ -7,6 +7,7 @@ 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
@@ -58,6 +59,8 @@ static NSString *g_outputPath = nil;
         g_isCleaningUp = NO;
     }
     
+    g_currentCaptureInfo = nil;
+
     NSString *outputPath = config[@"outputPath"];
     if (!outputPath || [outputPath length] == 0) {
         NSLog(@"❌ Invalid output path provided");
@@ -124,6 +127,34 @@ static NSString *g_outputPath = 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;
@@ -163,6 +194,24 @@ static NSString *g_outputPath = 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
@@ -393,7 +442,8 @@ static NSString *g_outputPath = nil;
             // SCRecordingOutput finalizes automatically
             NSLog(@"✅ Pure recording output finalized");
         }
-        
+
+        g_currentCaptureInfo = nil;
         [ScreenCaptureKitRecorder cleanupVideoWriter];
     }
 }
@@ -431,4 +481,10 @@ static NSString *g_outputPath = nil;
     }
 }
 
-@end
++ (NSDictionary *)currentCaptureInfo {
+    @synchronized([ScreenCaptureKitRecorder class]) {
+        return g_currentCaptureInfo;
+    }
+}
+
+@end