@midscene/computer 1.12.2 → 1.12.3-beta-20260828110230.0

package/dist/lib/cli.js

@@ -54,6 +54,7 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
+const MOUSE_COORDINATE_TOLERANCE_PX = 5;
 class ComputerInputDriver {
     destroy() {
         if (this.destroyed) return;
@@ -69,6 +70,15 @@ class ComputerInputDriver {
     moveMouse(x, y) {
         this.getLibnutOrThrow('moveMouse').moveMouse(x, y);
     }
+    assertMousePosition(targetX, targetY, context) {
+        const current = this.getMousePos();
+        const drift = {
+            x: current.x - targetX,
+            y: current.y - targetY
+        };
+        if (Math.abs(drift.x) > MOUSE_COORDINATE_TOLERANCE_PX || Math.abs(drift.y) > MOUSE_COORDINATE_TOLERANCE_PX) throw new Error(`${context}: expected (${targetX}, ${targetY}), got (${current.x}, ${current.y}), drift=(${drift.x}, ${drift.y})`);
+        return drift;
+    }
     focusActiveWindow() {
         const lib = this.getLibnutOrThrow('focusActiveWindow');
         if ('function' != typeof lib.getActiveWindow || 'function' != typeof lib.focusWindow) return false;
@@ -209,6 +219,122 @@ class ComputerInputDriver {
         this.pendingInputDelayWaits = new Set();
     }
 }
+const WINDOWS_PHYSICAL_PIXEL_POWERSHELL_PREAMBLE = `
+$midsceneAssemblyName = New-Object System.Reflection.AssemblyName('MidsceneDpiNative')
+$midsceneAssembly = [System.AppDomain]::CurrentDomain.DefineDynamicAssembly(
+  $midsceneAssemblyName,
+  [System.Reflection.Emit.AssemblyBuilderAccess]::Run
+)
+$midsceneModule = $midsceneAssembly.DefineDynamicModule('MidsceneDpiNativeModule')
+$midsceneType = $midsceneModule.DefineType(
+  'MidsceneDpiNative.User32',
+  [System.Reflection.TypeAttributes]'Public, Class, Sealed, Abstract'
+)
+$midsceneMethodAttributes =
+  [System.Reflection.MethodAttributes]::Public -bor
+  [System.Reflection.MethodAttributes]::Static -bor
+  [System.Reflection.MethodAttributes]::PinvokeImpl
+$midsceneSetDpiMethod = $midsceneType.DefinePInvokeMethod(
+  'SetThreadDpiAwarenessContext',
+  'user32.dll',
+  $midsceneMethodAttributes,
+  [System.Reflection.CallingConventions]::Standard,
+  [System.IntPtr],
+  [System.Type[]]@([System.IntPtr]),
+  [System.Runtime.InteropServices.CallingConvention]::Winapi,
+  [System.Runtime.InteropServices.CharSet]::None
+)
+$midsceneSetDpiMethod.SetImplementationFlags(
+  $midsceneSetDpiMethod.GetMethodImplementationFlags() -bor
+  [System.Reflection.MethodImplAttributes]::PreserveSig
+)
+$midsceneNativeMethods = $midsceneType.CreateType()
+$midscenePerMonitorV2 = [System.IntPtr](-4)
+$midscenePreviousDpiContext =
+  $midsceneNativeMethods::SetThreadDpiAwarenessContext($midscenePerMonitorV2)
+if ($midscenePreviousDpiContext -eq [System.IntPtr]::Zero) {
+  throw 'Unable to enter the Per-Monitor V2 DPI awareness context.'
+}
+`.trim();
+function windows_pointer_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const WINDOWS_POINTER_TOLERANCE_PX = 5;
+function assertFinitePoint(point, context) {
+    if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) throw new Error(`${context} must contain finite coordinates, got (${point.x}, ${point.y})`);
+}
+function parseWindowsPointerPosition(output, context) {
+    const match = output.trim().match(/^(-?\d+),(-?\d+)$/);
+    if (!match) throw new Error(`${context} returned an invalid cursor position: ${JSON.stringify(output.trim())}`);
+    return {
+        x: Number(match[1]),
+        y: Number(match[2])
+    };
+}
+function windowsPointerPositionScript() {
+    return `
+${WINDOWS_PHYSICAL_PIXEL_POWERSHELL_PREAMBLE}
+Add-Type -AssemblyName System.Windows.Forms, System.Drawing
+$position = [System.Windows.Forms.Cursor]::Position
+[Console]::Out.Write(('{0},{1}' -f $position.X, $position.Y))
+`.trim();
+}
+function windowsPointerMoveScript(point, options) {
+    assertFinitePoint(point, 'Windows pointer target');
+    if (options?.smoothSteps !== void 0 && !Number.isFinite(options.smoothSteps) || options?.smoothDelayMs !== void 0 && !Number.isFinite(options.smoothDelayMs)) throw new Error('Windows pointer smoothing options must be finite numbers');
+    const targetX = Math.round(point.x);
+    const targetY = Math.round(point.y);
+    const smoothSteps = Math.max(1, Math.round(options?.smoothSteps ?? 1));
+    const smoothDelayMs = Math.max(0, Math.round(options?.smoothDelayMs ?? 0));
+    return `
+${WINDOWS_PHYSICAL_PIXEL_POWERSHELL_PREAMBLE}
+Add-Type -AssemblyName System.Windows.Forms, System.Drawing
+$targetX = ${targetX}
+$targetY = ${targetY}
+$smoothSteps = ${smoothSteps}
+$smoothDelayMs = ${smoothDelayMs}
+$start = [System.Windows.Forms.Cursor]::Position
+for ($step = 1; $step -le $smoothSteps; $step += 1) {
+  $x = [int][Math]::Round($start.X + (($targetX - $start.X) * $step / [double]$smoothSteps))
+  $y = [int][Math]::Round($start.Y + (($targetY - $start.Y) * $step / [double]$smoothSteps))
+  [System.Windows.Forms.Cursor]::Position = [System.Drawing.Point]::new($x, $y)
+  if ($smoothDelayMs -gt 0 -and $step -lt $smoothSteps) {
+    Start-Sleep -Milliseconds $smoothDelayMs
+  }
+}
+[System.Windows.Forms.Cursor]::Position = [System.Drawing.Point]::new($targetX, $targetY)
+$position = [System.Windows.Forms.Cursor]::Position
+[Console]::Out.Write(('{0},{1}' -f $position.X, $position.Y))
+`.trim();
+}
+class WindowsPointerDriver {
+    getPosition() {
+        return parseWindowsPointerPosition(this.options.runPowershell(windowsPointerPositionScript()), 'Windows pointer query');
+    }
+    moveTo(point, options) {
+        return parseWindowsPointerPosition(this.options.runPowershell(windowsPointerMoveScript(point, options)), 'Windows pointer move');
+    }
+    constructor(options){
+        windows_pointer_define_property(this, "options", void 0);
+        this.options = options;
+    }
+}
+function windowsPointerDrift(expected, actual) {
+    return {
+        x: actual.x - expected.x,
+        y: actual.y - expected.y
+    };
+}
+function windowsPointerIsWithinTolerance(drift) {
+    return Math.abs(drift.x) <= WINDOWS_POINTER_TOLERANCE_PX && Math.abs(drift.y) <= WINDOWS_POINTER_TOLERANCE_PX;
+}
 const interrupt_namespaceObject = require("@midscene/shared/cli/interrupt");
 const debugXvfb = (0, logger_namespaceObject.getDebug)('computer:xvfb');
 const xvfbCleanupMonitorScript = String.raw`
@@ -487,19 +613,34 @@ function runPowershell(script) {
         windowsHide: true
     });
 }
-function listWindowsDisplays() {
+function readWindowsDisplayGeometries() {
     const script = `
+${WINDOWS_PHYSICAL_PIXEL_POWERSHELL_PREAMBLE}
 Add-Type -AssemblyName System.Windows.Forms
 $s = [System.Windows.Forms.Screen]::AllScreens | ForEach-Object {
-  [PSCustomObject]@{ id = $_.DeviceName; name = $_.DeviceName; primary = $_.Primary }
+  $b = $_.Bounds
+  [PSCustomObject]@{
+    id = $_.DeviceName
+    name = $_.DeviceName
+    primary = $_.Primary
+    bounds = [PSCustomObject]@{ x = $b.X; y = $b.Y; width = $b.Width; height = $b.Height }
+  }
 }
 ConvertTo-Json @($s) -Compress
 `.trim();
-    const parsed = JSON.parse(runPowershell(script).trim());
-    return parsed.map((d)=>({
-            id: String(d.id),
-            name: d.name || String(d.id),
-            primary: d.primary || false
+    const output = runPowershell(script).trim();
+    if (!output) throw new Error('Windows display enumeration returned no data');
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed)) throw new Error('Windows display enumeration returned invalid data');
+    const displays = parsed.filter(isWindowsDisplayGeometry);
+    if (displays.length !== parsed.length || 0 === displays.length) throw new Error('Windows display enumeration returned invalid geometry');
+    return displays;
+}
+function listWindowsDisplays(geometries = readWindowsDisplayGeometries()) {
+    return geometries.map((display)=>({
+            id: display.id,
+            name: display.name,
+            primary: display.primary
         }));
 }
 let device_libnut = null;
@@ -601,6 +742,16 @@ function getDisplayInfoBinary() {
 function isFiniteNumber(value) {
     return 'number' == typeof value && Number.isFinite(value);
 }
+function isDisplayBounds(value) {
+    if (!value || 'object' != typeof value) return false;
+    const bounds = value;
+    return isFiniteNumber(bounds.x) && isFiniteNumber(bounds.y) && isFiniteNumber(bounds.width) && isFiniteNumber(bounds.height) && bounds.width > 0 && bounds.height > 0;
+}
+function isWindowsDisplayGeometry(value) {
+    if (!value || 'object' != typeof value) return false;
+    const candidate = value;
+    return 'string' == typeof candidate.id && candidate.id.length > 0 && 'string' == typeof candidate.name && 'boolean' == typeof candidate.primary && isDisplayBounds(candidate.bounds);
+}
 function isDarwinDisplayGeometry(value) {
     if (!value || 'object' != typeof value) return false;
     const candidate = value;
@@ -643,9 +794,11 @@ function readDarwinFrontmostApplication() {
         return;
     }
 }
-async function pressMouseAtGlobalPoint(inputDriver, targetX, targetY, holdDuration, reason) {
-    await inputDriver.delay(CLICK_SETTLE_DELAY);
-    const current = inputDriver.getMousePos();
+async function pressMouseAtGlobalPoint(inputDriver, targetX, targetY, current, holdDuration, reason) {
+    const drift = {
+        x: current.x - targetX,
+        y: current.y - targetY
+    };
     debugComputerInput('tap mouse moved %o', {
         reason,
         target: {
@@ -653,10 +806,7 @@ async function pressMouseAtGlobalPoint(inputDriver, targetX, targetY, holdDurati
             y: targetY
         },
         current,
-        drift: {
-            x: current.x - targetX,
-            y: current.y - targetY
-        }
+        drift
     });
     await inputDriver.withMouseButton('left', async ()=>{
         debugComputerInput('tap mouse down %o', {
@@ -675,9 +825,18 @@ function resolveDarwinDisplayGeometryFromList(displayId, displays) {
     if (void 0 === displayId || '' === displayId) return displays.find((display)=>display.primary) || displays.find((display)=>0 === display.screenIndex) || displays[0];
     return displays.find((display)=>display.screenIndex === screenIndex) || displays.find((display)=>display.cgDisplayId === screenIndex);
 }
-function resolveDisplayGeometry(displayId) {
-    if ('darwin' !== process.platform) return;
-    return resolveDarwinDisplayGeometryFromList(displayId, readDarwinDisplayGeometries());
+function resolveWindowsDisplayGeometryFromList(displayId, displays) {
+    if (!displays.length) return;
+    if (void 0 === displayId || '' === displayId) return displays.find((display)=>display.primary) || displays[0];
+    return displays.find((display)=>display.id === displayId);
+}
+function resolveDisplayGeometry(displayId, windowsDisplays) {
+    if ('darwin' === process.platform) return resolveDarwinDisplayGeometryFromList(displayId, readDarwinDisplayGeometries());
+    if ('win32' === process.platform) {
+        const geometry = resolveWindowsDisplayGeometryFromList(displayId, windowsDisplays ?? readWindowsDisplayGeometries());
+        if (!geometry) throw new Error(displayId ? `Requested Windows display not found: ${displayId}` : 'No Windows displays were detected');
+        return geometry;
+    }
 }
 function mapDisplayLocalPointToGlobal(point, geometry) {
     if (!geometry) return point;
@@ -763,6 +922,30 @@ function normalizePrimaryKey(key) {
     return KEY_NAME_MAP[lowerKey] || lowerKey;
 }
 class ComputerDevice {
+    async moveGlobalPointer(point, context, smooth) {
+        if (this.destroyed) throw new Error('ComputerDevice has been destroyed');
+        const target = {
+            x: Math.round(point.x),
+            y: Math.round(point.y)
+        };
+        if ('win32' === process.platform) {
+            const actual = this.windowsPointerDriver.moveTo(target, {
+                smoothSteps: smooth?.smoothSteps,
+                smoothDelayMs: smooth?.smoothDelay
+            });
+            const drift = windowsPointerDrift(target, actual);
+            if (!windowsPointerIsWithinTolerance(drift)) throw new Error(`${context}: expected (${target.x}, ${target.y}), got (${actual.x}, ${actual.y}), drift=(${drift.x}, ${drift.y})`);
+            await this.inputDriver.delay(CLICK_SETTLE_DELAY);
+            return actual;
+        }
+        if (smooth) await this.inputDriver.smoothMoveMouse(target.x, target.y, smooth.smoothSteps, smooth.smoothDelay);
+        else this.inputDriver.moveMouse(target.x, target.y);
+        await this.inputDriver.delay(CLICK_SETTLE_DELAY);
+        return target;
+    }
+    moveDisplayPointer(point, context, smooth) {
+        return this.moveGlobalPointer(this.toGlobalPoint(point), context, smooth);
+    }
     async focusKeyboardTarget(element, delayMs) {
         const [x, y] = element.center;
         if ('darwin' === process.platform) await this.inputPrimitives.pointer.tap({
@@ -770,11 +953,10 @@ class ComputerDevice {
             y
         });
         else {
-            const point = this.toGlobalPoint({
+            await this.moveDisplayPointer({
                 x,
                 y
-            });
-            this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
+            }, 'Mouse did not reach the keyboard focus target');
             this.inputDriver.mouseClick('left');
         }
         await this.inputDriver.delay(delayMs);
@@ -793,7 +975,7 @@ class ComputerDevice {
                 }));
         } catch (error) {
             debugDevice(`Failed to list displays: ${error}`);
-            return [];
+            throw new Error(`Failed to list displays: ${error}`);
         }
     }
     async connect() {
@@ -822,9 +1004,10 @@ class ComputerDevice {
                 }
             }
             device_libnut = await getLibnut();
-            this.displayGeometry = resolveDisplayGeometry(this.displayId);
+            const windowsDisplayGeometries = 'win32' === process.platform ? readWindowsDisplayGeometries() : void 0;
+            this.displayGeometry = resolveDisplayGeometry(this.displayId, windowsDisplayGeometries);
             const size = await this.size();
-            const displays = await ComputerDevice.listDisplays();
+            const displays = windowsDisplayGeometries ? listWindowsDisplays(windowsDisplayGeometries) : await ComputerDevice.listDisplays();
             const headlessInfo = this.xvfbInstance ? `\nHeadless: true (Xvfb on ${this.xvfbInstance.display})` : '';
             this.description = `
 Type: Computer
@@ -834,7 +1017,7 @@ Screen Size: ${size.width}x${size.height}
 Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ') : 'Unknown'}${headlessInfo}
 `;
             debugDevice('Computer device connected', this.description);
-            await this.healthCheck();
+            await this.healthCheck(displays);
         } catch (error) {
             if (this.xvfbInstance) {
                 if (!this.options?.keepXvfbAliveUntilProcessExit) this.xvfbInstance.stop();
@@ -853,9 +1036,9 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             throw new Error(`Unable to connect to computer device: ${error}`);
         }
     }
-    async healthCheck() {
+    async healthCheck(displays) {
         console.log('[HealthCheck] Starting health check...');
-        console.log("[HealthCheck] @midscene/computer v1.12.2");
+        console.log("[HealthCheck] @midscene/computer v1.12.3-beta-20260828110230.0");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -867,23 +1050,38 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             timeoutPromise
         ]);
         console.log(`[HealthCheck] Screenshot succeeded (length=${base64.length})`);
-        console.log('[HealthCheck] Moving mouse...');
-        const startPos = this.inputDriver.getMousePos();
+        console.log('[HealthCheck] Verifying mouse control...');
+        const startPos = 'win32' === process.platform ? this.windowsPointerDriver.getPosition() : this.inputDriver.getMousePos();
         console.log(`[HealthCheck] Current mouse position: (${startPos.x}, ${startPos.y})`);
-        const offsetX = Math.floor(40 * Math.random()) + 10;
-        const offsetY = Math.floor(40 * Math.random()) + 10;
-        const targetX = startPos.x + offsetX;
-        const targetY = startPos.y + offsetY;
-        console.log(`[HealthCheck] Moving mouse to (${targetX}, ${targetY})...`);
-        this.inputDriver.moveMouse(targetX, targetY);
-        await (0, utils_namespaceObject.sleep)(50);
-        const movedPos = this.inputDriver.getMousePos();
-        console.log(`[HealthCheck] Mouse position after move: (${movedPos.x}, ${movedPos.y})`);
-        const deltaX = Math.abs(movedPos.x - targetX);
-        const deltaY = Math.abs(movedPos.y - targetY);
-        if (deltaX > 5 || deltaY > 5) {
-            const msg = `[HealthCheck] WARNING: Mouse control may not be working. Expected (${targetX}, ${targetY}), got (${movedPos.x}, ${movedPos.y}), delta=(${deltaX}, ${deltaY})`;
-            warnDevice(msg);
+        if ('win32' === process.platform) {
+            if (!this.displayGeometry) throw new Error('Windows display geometry is unavailable');
+            const bounds = this.displayGeometry.bounds;
+            const target = {
+                x: Math.round(bounds.x + bounds.width / 2),
+                y: Math.round(bounds.y + bounds.height / 2)
+            };
+            try {
+                const actual = this.windowsPointerDriver.moveTo(target);
+                const drift = windowsPointerDrift(target, actual);
+                if (!windowsPointerIsWithinTolerance(drift)) throw new Error(`Windows screenshot-space pointer verification: expected (${target.x}, ${target.y}), got (${actual.x}, ${actual.y}), drift=(${drift.x}, ${drift.y})`);
+            } finally{
+                this.windowsPointerDriver.moveTo(startPos);
+            }
+            console.log(`[HealthCheck] Mouse verified in screenshot-space display bounds (${bounds.x}, ${bounds.y}, ${bounds.width}, ${bounds.height})`);
+        } else {
+            const offsetX = Math.floor(40 * Math.random()) + 10;
+            const offsetY = Math.floor(40 * Math.random()) + 10;
+            const targetX = startPos.x + offsetX;
+            const targetY = startPos.y + offsetY;
+            console.log(`[HealthCheck] Moving mouse to (${targetX}, ${targetY})...`);
+            try {
+                this.inputDriver.moveMouse(targetX, targetY);
+                await (0, utils_namespaceObject.sleep)(CLICK_SETTLE_DELAY);
+                this.inputDriver.assertMousePosition(targetX, targetY, 'Mouse health check failed');
+            } finally{
+                this.inputDriver.moveMouse(startPos.x, startPos.y);
+                console.log(`[HealthCheck] Mouse restored to (${startPos.x}, ${startPos.y})`);
+            }
         }
         if ('win32' === process.platform && !this.isRunningAsAdmin()) {
             const hint = [
@@ -893,10 +1091,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             ].join(' ');
             warnDevice(`[HealthCheck] ${hint}`);
         }
-        this.inputDriver.moveMouse(startPos.x, startPos.y);
-        console.log(`[HealthCheck] Mouse restored to (${startPos.x}, ${startPos.y})`);
         console.log('[HealthCheck] Listing monitors...');
-        const displays = await ComputerDevice.listDisplays();
         if (displays.length > 0) {
             console.log(`[HealthCheck] Found ${displays.length} monitor(s):`);
             for (const display of displays){
@@ -965,6 +1160,7 @@ $screen = [System.Windows.Forms.Screen]::AllScreens | Where-Object { $_.DeviceNa
 if (-not $screen) { throw "Requested display not found: $dn" }` : '$screen = [System.Windows.Forms.Screen]::PrimaryScreen';
         const script = `
 $ErrorActionPreference = 'Stop'
+${WINDOWS_PHYSICAL_PIXEL_POWERSHELL_PREAMBLE}
 Add-Type -AssemblyName System.Windows.Forms, System.Drawing
 ${selectScreen}
 $b = $screen.Bounds
@@ -1079,10 +1275,14 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
     resolveUntargetedScrollPoint(screenSize) {
         if ('win32' === process.platform) {
             const activeWindowRect = this.inputDriver.getActiveWindowRect();
-            if (activeWindowRect) return {
-                x: activeWindowRect.x + activeWindowRect.width / 2,
-                y: activeWindowRect.y + activeWindowRect.height / 2
-            };
+            if (activeWindowRect) {
+                const activeWindowCenter = {
+                    x: activeWindowRect.x + activeWindowRect.width / 2,
+                    y: activeWindowRect.y + activeWindowRect.height / 2
+                };
+                const bounds = this.displayGeometry?.bounds;
+                if (!bounds || activeWindowCenter.x >= bounds.x && activeWindowCenter.x < bounds.x + bounds.width && activeWindowCenter.y >= bounds.y && activeWindowCenter.y < bounds.y + bounds.height) return activeWindowCenter;
+            }
         }
         return this.toGlobalPoint({
             x: screenSize.width / 2,
@@ -1093,17 +1293,16 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
         if (param.locate) {
             const element = param.locate;
             const [x, y] = element.center;
-            const point = this.toGlobalPoint({
+            await this.moveDisplayPointer({
                 x,
                 y
-            });
-            this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
+            }, 'Mouse did not reach the scroll target');
             return;
         }
         const screenSize = await this.size();
         if ('win32' === process.platform && this.inputDriver.focusActiveWindow()) await this.inputDriver.delay(CLICK_FOCUS_SETTLE_DELAY);
         const point = this.resolveUntargetedScrollPoint(screenSize);
-        this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
+        await this.moveGlobalPointer(point, 'Mouse did not reach the scroll viewport');
         await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
         return screenSize;
     }
@@ -1228,6 +1427,9 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
             runPhasedScroll,
             debug: (message)=>debugDevice(message)
         }));
+        device_define_property(this, "windowsPointerDriver", new WindowsPointerDriver({
+            runPowershell
+        }));
         device_define_property(this, "useAppleScript", void 0);
         device_define_property(this, "adminCheckCache", void 0);
         device_define_property(this, "uri", void 0);
@@ -1252,15 +1454,17 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                         },
                         holdDuration,
                         displayId: this.displayId,
-                        displayGeometry: this.displayGeometry ? {
-                            screenIndex: this.displayGeometry.screenIndex,
-                            cgDisplayId: this.displayGeometry.cgDisplayId,
-                            bounds: this.displayGeometry.bounds
-                        } : void 0
+                        displayGeometry: this.displayGeometry
                     });
                     const frontmostBefore = 'darwin' === process.platform ? readDarwinFrontmostApplication() : void 0;
-                    await this.inputDriver.smoothMoveMouse(targetX, targetY, SMOOTH_MOVE_STEPS_TAP, SMOOTH_MOVE_DELAY_TAP);
-                    await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, holdDuration, 'primary');
+                    const current = await this.moveGlobalPointer({
+                        x: targetX,
+                        y: targetY
+                    }, 'Mouse did not reach the tap target', {
+                        smoothSteps: SMOOTH_MOVE_STEPS_TAP,
+                        smoothDelay: SMOOTH_MOVE_DELAY_TAP
+                    });
+                    await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, current, holdDuration, 'primary');
                     if (frontmostBefore && 'darwin' === process.platform) {
                         await (0, utils_namespaceObject.sleep)(CLICK_FOCUS_SETTLE_DELAY);
                         const frontmostAfter = readDarwinFrontmostApplication();
@@ -1271,42 +1475,43 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                             focusChanged
                         });
                         if (focusChanged) {
-                            this.inputDriver.moveMouse(targetX, targetY);
-                            await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, holdDuration, 'focus-follow-up');
+                            const followUpCurrent = await this.moveGlobalPointer({
+                                x: targetX,
+                                y: targetY
+                            }, 'Mouse did not reach the focus follow-up target');
+                            await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, followUpCurrent, holdDuration, 'focus-follow-up');
                         }
                     }
                 },
                 doubleClick: async ({ x, y })=>{
-                    const target = this.toGlobalPoint({
+                    await this.moveDisplayPointer({
                         x,
                         y
-                    });
-                    this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
+                    }, 'Mouse did not reach the double-click target');
                     this.inputDriver.mouseClick('left', true);
                 },
                 rightClick: async ({ x, y })=>{
-                    const target = this.toGlobalPoint({
+                    await this.moveDisplayPointer({
                         x,
                         y
-                    });
-                    this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
+                    }, 'Mouse did not reach the right-click target');
                     this.inputDriver.mouseClick('right');
                 },
                 hover: async ({ x, y })=>{
-                    const target = this.toGlobalPoint({
+                    await this.moveDisplayPointer({
                         x,
                         y
+                    }, 'Mouse did not reach the hover target', {
+                        smoothSteps: SMOOTH_MOVE_STEPS_MOUSE_MOVE,
+                        smoothDelay: SMOOTH_MOVE_DELAY_MOUSE_MOVE
                     });
-                    await this.inputDriver.smoothMoveMouse(Math.round(target.x), Math.round(target.y), SMOOTH_MOVE_STEPS_MOUSE_MOVE, SMOOTH_MOVE_DELAY_MOUSE_MOVE);
                     await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
                 },
                 dragAndDrop: async (from, to)=>{
-                    const globalFrom = this.toGlobalPoint(from);
-                    const globalTo = this.toGlobalPoint(to);
-                    this.inputDriver.moveMouse(Math.round(globalFrom.x), Math.round(globalFrom.y));
+                    await this.moveDisplayPointer(from, 'Mouse did not reach the drag start target');
                     await this.inputDriver.withMouseButton('left', async ()=>{
                         await this.inputDriver.delay(100);
-                        this.inputDriver.moveMouse(Math.round(globalTo.x), Math.round(globalTo.y));
+                        await this.moveDisplayPointer(to, 'Mouse did not reach the drag end target');
                         await this.inputDriver.delay(100);
                     });
                 }
@@ -2265,7 +2470,7 @@ const tools = new ComputerMidsceneTools({
 });
 (0, cli_namespaceObject.runToolsCLI)(tools, 'midscene-computer', {
     stripPrefix: 'computer_',
-    version: "1.12.2",
+    version: "1.12.3-beta-20260828110230.0",
     extraCommands: (0, core_namespaceObject.createReportCliCommands)()
 }).catch((e)=>{
     process.exit((0, cli_namespaceObject.reportCLIError)(e));