@midscene/computer 1.12.3-beta-20260902081623.0 → 1.12.3

package/dist/es/cli.mjs

@@ -29,6 +29,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;
@@ -44,6 +45,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;
@@ -57,20 +67,6 @@ class ComputerInputDriver {
             return false;
         }
     }
-    getActiveWindowRect() {
-        const lib = this.getLibnutOrThrow('getActiveWindowRect');
-        if ('function' != typeof lib.getActiveWindow || 'function' != typeof lib.getWindowRect) return null;
-        try {
-            const handle = lib.getActiveWindow();
-            if (!handle) return null;
-            const rect = lib.getWindowRect(handle);
-            if (!Number.isFinite(rect.x) || !Number.isFinite(rect.y) || !Number.isFinite(rect.width) || !Number.isFinite(rect.height) || rect.width <= 0 || rect.height <= 0) return null;
-            return rect;
-        } catch (error) {
-            this.options.debug(`getActiveWindowRect failed: ${error}`);
-            return null;
-        }
-    }
     mouseClick(button, double) {
         const lib = this.getLibnutOrThrow('mouseClick');
         if (void 0 !== double) lib.mouseClick(button, double);
@@ -184,6 +180,207 @@ class ComputerInputDriver {
         this.pendingInputDelayWaits = new Set();
     }
 }
+const POWERSHELL_TIMEOUT_MS = 15000;
+const POWERSHELL_MAX_BUFFER = 67108864;
+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
+)
+$midsceneGetForegroundWindowMethod = $midsceneType.DefinePInvokeMethod(
+  'GetForegroundWindow',
+  'user32.dll',
+  $midsceneMethodAttributes,
+  [System.Reflection.CallingConventions]::Standard,
+  [System.IntPtr],
+  [System.Type[]]@(),
+  [System.Runtime.InteropServices.CallingConvention]::Winapi,
+  [System.Runtime.InteropServices.CharSet]::None
+)
+$midsceneGetForegroundWindowMethod.SetImplementationFlags(
+  $midsceneGetForegroundWindowMethod.GetMethodImplementationFlags() -bor
+  [System.Reflection.MethodImplAttributes]::PreserveSig
+)
+$midsceneGetWindowRectMethod = $midsceneType.DefinePInvokeMethod(
+  'GetWindowRect',
+  'user32.dll',
+  $midsceneMethodAttributes,
+  [System.Reflection.CallingConventions]::Standard,
+  [bool],
+  [System.Type[]]@([System.IntPtr], [System.IntPtr]),
+  [System.Runtime.InteropServices.CallingConvention]::Winapi,
+  [System.Runtime.InteropServices.CharSet]::None
+)
+$midsceneGetWindowRectMethod.SetImplementationFlags(
+  $midsceneGetWindowRectMethod.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 runWindowsPhysicalPixelPowershell(script) {
+    const physicalPixelScript = `$ProgressPreference = 'SilentlyContinue'
+$ErrorActionPreference = 'Stop'
+${WINDOWS_PHYSICAL_PIXEL_POWERSHELL_PREAMBLE}
+${script}`;
+    const encoded = Buffer.from(physicalPixelScript, 'utf16le').toString('base64');
+    return execFileSync('powershell.exe', [
+        '-NoProfile',
+        '-NonInteractive',
+        '-EncodedCommand',
+        encoded
+    ], {
+        encoding: 'utf8',
+        timeout: POWERSHELL_TIMEOUT_MS,
+        maxBuffer: POWERSHELL_MAX_BUFFER,
+        windowsHide: true
+    });
+}
+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 `
+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 `
+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();
+}
+function parseWindowsWindowRect(output) {
+    const value = output.trim();
+    if (!value) return null;
+    const match = value.match(/^(-?\d+),(-?\d+),(\d+),(\d+)$/);
+    if (!match) throw new Error(`Windows active window query returned an invalid rectangle: ${JSON.stringify(value)}`);
+    const rect = {
+        x: Number(match[1]),
+        y: Number(match[2]),
+        width: Number(match[3]),
+        height: Number(match[4])
+    };
+    if (rect.width <= 0 || rect.height <= 0) throw new Error(`Windows active window query returned an invalid rectangle: ${JSON.stringify(value)}`);
+    return rect;
+}
+function windowsActiveWindowRectScript() {
+    return `
+$midsceneWindowHandle = $midsceneNativeMethods::GetForegroundWindow()
+if ($midsceneWindowHandle -eq [System.IntPtr]::Zero) {
+  return
+}
+$midsceneWindowRectBuffer = [System.Runtime.InteropServices.Marshal]::AllocHGlobal(16)
+try {
+  if (-not $midsceneNativeMethods::GetWindowRect($midsceneWindowHandle, $midsceneWindowRectBuffer)) {
+    throw 'GetWindowRect failed for the foreground window.'
+  }
+  $left = [System.Runtime.InteropServices.Marshal]::ReadInt32($midsceneWindowRectBuffer, 0)
+  $top = [System.Runtime.InteropServices.Marshal]::ReadInt32($midsceneWindowRectBuffer, 4)
+  $right = [System.Runtime.InteropServices.Marshal]::ReadInt32($midsceneWindowRectBuffer, 8)
+  $bottom = [System.Runtime.InteropServices.Marshal]::ReadInt32($midsceneWindowRectBuffer, 12)
+  [Console]::Out.Write(('{0},{1},{2},{3}' -f $left, $top, ($right - $left), ($bottom - $top)))
+}
+finally {
+  [System.Runtime.InteropServices.Marshal]::FreeHGlobal($midsceneWindowRectBuffer)
+}
+`.trim();
+}
+class WindowsPointerDriver {
+    getPosition() {
+        return parseWindowsPointerPosition(this.options.runPhysicalPixelPowershell(windowsPointerPositionScript()), 'Windows pointer query');
+    }
+    getActiveWindowRect() {
+        return parseWindowsWindowRect(this.options.runPhysicalPixelPowershell(windowsActiveWindowRectScript()));
+    }
+    moveTo(point, options) {
+        return parseWindowsPointerPosition(this.options.runPhysicalPixelPowershell(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 debugXvfb = getDebug('computer:xvfb');
 const xvfbCleanupMonitorScript = String.raw`
 const parentPid = Number(process.argv[1]);
@@ -441,39 +638,36 @@ function sendKeyViaAppleScript(key, modifiers = []) {
         script
     ]);
 }
-const POWERSHELL_TIMEOUT_MS = 15000;
-const POWERSHELL_MAX_BUFFER = 67108864;
 function escapePowershellSingleQuoted(value) {
     return value.replace(/'/g, "''");
 }
-function runPowershell(script) {
-    const prefixed = `$ProgressPreference = 'SilentlyContinue'\n${script}`;
-    const encoded = Buffer.from(prefixed, 'utf16le').toString('base64');
-    return execFileSync('powershell.exe', [
-        '-NoProfile',
-        '-NonInteractive',
-        '-EncodedCommand',
-        encoded
-    ], {
-        encoding: 'utf8',
-        timeout: POWERSHELL_TIMEOUT_MS,
-        maxBuffer: POWERSHELL_MAX_BUFFER,
-        windowsHide: true
-    });
-}
-function listWindowsDisplays() {
+function readWindowsDisplayGeometries() {
     const script = `
 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 = runWindowsPhysicalPixelPowershell(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;
@@ -575,6 +769,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;
@@ -617,9 +821,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: {
@@ -627,10 +833,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', {
@@ -649,9 +852,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;
@@ -737,6 +949,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 this.inputDriver.getMousePos();
+    }
+    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({
@@ -744,11 +980,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);
@@ -767,7 +1002,7 @@ class ComputerDevice {
                 }));
         } catch (error) {
             debugDevice(`Failed to list displays: ${error}`);
-            return [];
+            throw new Error(`Failed to list displays: ${error}`);
         }
     }
     async connect() {
@@ -796,9 +1031,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
@@ -808,7 +1044,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();
@@ -827,9 +1063,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.3-beta-20260902081623.0");
+        console.log("[HealthCheck] @midscene/computer v1.12.3");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -841,23 +1077,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 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 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 = [
@@ -867,10 +1118,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){
@@ -938,7 +1186,6 @@ Original error: ${lastRawMessage}`);
 $screen = [System.Windows.Forms.Screen]::AllScreens | Where-Object { $_.DeviceName -eq $dn } | Select-Object -First 1
 if (-not $screen) { throw "Requested display not found: $dn" }` : '$screen = [System.Windows.Forms.Screen]::PrimaryScreen';
         const script = `
-$ErrorActionPreference = 'Stop'
 Add-Type -AssemblyName System.Windows.Forms, System.Drawing
 ${selectScreen}
 $b = $screen.Bounds
@@ -952,7 +1199,7 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
 `.trim();
         let stdout;
         try {
-            stdout = runPowershell(script);
+            stdout = runWindowsPhysicalPixelPowershell(script);
         } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Failed to take screenshot on Windows: ${message}`);
@@ -1054,11 +1301,15 @@ $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
-            };
+            const activeWindowRect = this.windowsPointerDriver.getActiveWindowRect();
+            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,
@@ -1069,17 +1320,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;
     }
@@ -1204,6 +1454,9 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
             runPhasedScroll,
             debug: (message)=>debugDevice(message)
         }));
+        device_define_property(this, "windowsPointerDriver", new WindowsPointerDriver({
+            runPhysicalPixelPowershell: runWindowsPhysicalPixelPowershell
+        }));
         device_define_property(this, "useAppleScript", void 0);
         device_define_property(this, "adminCheckCache", void 0);
         device_define_property(this, "uri", void 0);
@@ -1228,15 +1481,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 sleep(CLICK_FOCUS_SETTLE_DELAY);
                         const frontmostAfter = readDarwinFrontmostApplication();
@@ -1247,42 +1502,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);
                     });
                 }
@@ -2255,7 +2511,7 @@ const tools = new ComputerMidsceneTools({
 });
 runToolsCLI(tools, 'midscene-computer', {
     stripPrefix: 'computer_',
-    version: "1.12.3-beta-20260902081623.0",
+    version: "1.12.3",
     extraCommands: createReportCliCommands()
 }).catch((e)=>{
     process.exit(reportCLIError(e));