node-mac-recorder 2.17.9 → 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,51 +395,105 @@ class MacRecorder extends EventEmitter {
 					this.isRecording = true;
 					this.recordingStartTime = Date.now();
 
-					// 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
+						// 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);
+										}
 									}
-								}).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);
+
+									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 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,
+								} 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);
+									});
+								}
+							};
+
+							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);
@@ -712,6 +805,16 @@ 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;
@@ -745,12 +848,40 @@ class MacRecorder extends EventEmitter {
 				? captureArea.x
 				: (targetDisplay && hasNumber(globalX) && hasNumber(targetDisplay.x)
 					? globalX - targetDisplay.x
-					: globalX);
+					: globalX ?? 0);
 			const displayOffsetY = captureArea && hasNumber(captureArea.y)
 				? captureArea.y
 				: (targetDisplay && hasNumber(globalY) && hasNumber(targetDisplay.y)
 					? globalY - targetDisplay.y
-					: globalY);
+					: 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:
@@ -762,25 +893,40 @@ 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: {
-					...windowInfo,
-					globalX,
-					globalY,
-					displayOffsetX,
-					displayOffsetY
+					...enrichedWindowInfo
 				},
 				targetDisplay,
-				captureArea
+				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) {
@@ -796,8 +942,16 @@ class MacRecorder extends EventEmitter {
 						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) {
@@ -813,15 +967,24 @@ 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);
 
 						// Transform coordinates based on recording type
 						let x = position.x;
@@ -830,9 +993,30 @@ class MacRecorder extends EventEmitter {
 
 						if (this.cursorDisplayInfo) {
 							if (this.cursorDisplayInfo.windowRelative) {
-								// Window recording: Transform global → window-relative coordinates
-								x = position.x - this.cursorDisplayInfo.x;
-								y = position.y - this.cursorDisplayInfo.y;
+								// 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;
+								}
 								coordinateSystem = "window-relative";
 
 								// Window bounds check - skip if cursor is outside window
@@ -857,11 +1041,28 @@ 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: 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,
@@ -870,7 +1071,14 @@ class MacRecorder extends EventEmitter {
 								windowInfo: {
 									width: this.cursorDisplayInfo.width,
 									height: this.cursorDisplayInfo.height,
-									displayId: this.cursorDisplayInfo.displayId
+									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
@@ -878,7 +1086,11 @@ class MacRecorder extends EventEmitter {
 								displayInfo: {
 									displayId: this.cursorDisplayInfo.displayId,
 									width: this.cursorDisplayInfo.width,
-									height: this.cursorDisplayInfo.height
+									height: this.cursorDisplayInfo.height,
+									pixelWidth: this.cursorDisplayInfo.pixelWidth ?? (this.cursorDisplayInfo.width * scaleX),
+									pixelHeight: this.cursorDisplayInfo.pixelHeight ?? (this.cursorDisplayInfo.height * scaleY),
+									scaleX,
+									scaleY
 								}
 							})
 						};
@@ -937,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);
@@ -1062,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.9",
+	"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