@bobfrankston/winpos 2.0.50 → 2.0.52

package/README.md

@@ -89,6 +89,7 @@ Screens are numbered starting from 0, sorted by position:
 - `-title <name>` - Window title/pattern (alternative to positional)
 - `-pos x,y[,screen]` - Position (comma-separated, screen optional)
 - `-size w,h` - Window size (width,height)
+- `-numsize <inches>` - Physical size of the screen-number overlays (default 2)
 - `-min` - Minimize window
 - `-max` - Maximize window
 - `-load <file>` - Load config from JSON file
@@ -96,6 +97,37 @@ Screens are numbered starting from 0, sorted by position:
 - `*` - List all windows
 - `**` - List all windows including ignored
 
+## Identifying Screens
+
+`winpos` with no arguments, and `winpos *` (or `**`), flash each screen's number
+in the middle of that screen for 5 seconds - the same idea as the Identify
+button in Windows display settings, so you can see which physical monitor is
+screen 0, 1, 2 ... before positioning anything there. With no arguments the
+numbers come up alongside the usage text and its screen table.
+
+The numbers are drawn with [msger](https://www.npmjs.com/package/@bobfrankston/msger)
+and all appear at once. They close themselves; winpos returns immediately
+without waiting for them. If msger is unavailable the listing still works, just
+without the numbers.
+
+Each overlay is 2 inches square **on the glass**, not 2 inches' worth of pixels
+- `-numsize <inches>` changes that. Sizing anything in pixels (or in CSS
+inches, which are just 96 pixels) comes out a different physical size on every
+monitor, because Windows' scale factor is a preference rather than a
+measurement: a 28" 4K panel left at 100% claims 96 DPI while really being 160.
+winpos asks the display driver for the panel's physical millimetres (EDID, via
+a GDI display DC) and works out each screen's true DPI, so the same square of
+glass lights up on every monitor. Drivers that report nothing fall back to the
+old pixel sizing.
+
+```typescript
+import { showScreenNumbers, enumerateScreens, sortScreens, screenDpi } from '@bobfrankston/winpos';
+
+const screens = sortScreens(enumerateScreens());
+await showScreenNumbers(screens, 5, 2);     // 5 seconds, 2 inches
+console.log(screens.map(screenDpi));        // True DPI per screen
+```
+
 ## Parameters
 
 ### Positional (legacy)

package/ffi-wrapper.d.ts

@@ -25,8 +25,11 @@ export interface MONITORINFO {
     rcMonitor: RECT;
     rcWork: RECT;
     dwFlags: number;
+    /** Display device name, e.g. \\.\DISPLAY1 (MONITORINFOEXW szDevice) */
+    szDevice?: string;
 }
 export declare const MONITORINFOF_PRIMARY = 1;
+export declare const DEFAULT_SCALE_PERCENT = 100;
 export interface WindowsAPI {
     EnumWindows: (callback: (hwnd: bigint, lParam: bigint) => boolean, lParam: bigint) => boolean;
     GetWindowTextW: (hwnd: bigint, text: any, maxCount: number) => number;
@@ -39,6 +42,13 @@ export interface WindowsAPI {
     GetWindowPlacement: (hwnd: bigint, placement: any) => boolean;
     EnumDisplayMonitors: (callback: (hMonitor: bigint, hdcMonitor: bigint, lprcMonitor: any, dwData: bigint) => boolean, dwData: bigint) => boolean;
     GetMonitorInfoW: (hMonitor: bigint, lpmi: any) => boolean;
+    /** Monitor scale factor as a percent (100, 125, 150...). 100 when unavailable. */
+    GetScaleFactorForMonitor?: (hMonitor: bigint) => number;
+    /** Physical panel size in millimetres from the display driver (EDID). Null when unavailable. */
+    GetPhysicalSizeMm?: (deviceName: string) => {
+        width: number;
+        height: number;
+    } | null;
 }
 declare const user32: WindowsAPI;
 export { user32, isBun };

package/ffi-wrapper.js

@@ -16,7 +16,12 @@ export const SW_MINIMIZE = 6;
 export const SW_SHOWMINNOACTIVE = 7;
 export const SW_SHOWNA = 8;
 export const SW_RESTORE = 9;
+// GetDeviceCaps indices for the panel's physical size in millimetres
+const HORZSIZE = 4;
+const VERTSIZE = 6;
 export const MONITORINFOF_PRIMARY = 1;
+// Monitor scale factor as a percentage (100 = no scaling, 125 = 125%)
+export const DEFAULT_SCALE_PERCENT = 100;
 async function initializeFFI() {
     if (isBun) {
         // @ts-ignore - bun:ffi is only available in Bun
@@ -95,6 +100,34 @@ async function initializeFFI() {
     const MonitorEnumProc = koffi.proto('bool __stdcall MonitorEnumProc(void *hMonitor, void *hdcMonitor, RECT *lprcMonitor, void *dwData)');
     const EnumDisplayMonitors = lib.func('bool __stdcall EnumDisplayMonitors(void *hdc, RECT *lprcClip, MonitorEnumProc *lpfnEnum, void *dwData)');
     const GetMonitorInfoW = lib.func('bool __stdcall GetMonitorInfoW(void *hMonitor, void *lpmi)');
+    // Per-monitor scaling lives in shcore.dll (Windows 8.1+). Optional: a
+    // missing shcore just means every monitor reports 100%.
+    // GetScaleFactorForMonitor, not GetDpiForMonitor: the DPI call reports the
+    // DPI *as the calling process sees it*, and winpos is DPI-unaware, so it
+    // always answers 96. This one reports the monitor's real scale factor.
+    let GetScaleFactorForMonitorRaw = null;
+    try {
+        const shcore = koffi.load('shcore.dll');
+        GetScaleFactorForMonitorRaw = shcore.func('int __stdcall GetScaleFactorForMonitor(void *hMonitor, void *pScale)');
+    }
+    catch {
+        // Leave null - callers fall back to 100%
+    }
+    // A display DC reports the panel's physical size in millimetres, straight
+    // from the driver's EDID. That is the only measurement of a monitor
+    // available: the scale factor above is a user preference, so a 160 DPI
+    // panel left at 100% claims to be a 96 DPI one. Optional, like shcore -
+    // callers fall back to nominal DPI when this returns null.
+    let CreateDCW = null, GetDeviceCaps = null, DeleteDC = null;
+    try {
+        const gdi32 = koffi.load('gdi32.dll');
+        CreateDCW = gdi32.func('void * __stdcall CreateDCW(const char16_t *pwszDriver, const char16_t *pwszDevice, const char16_t *pszPort, const void *pdm)');
+        GetDeviceCaps = gdi32.func('int __stdcall GetDeviceCaps(void *hdc, int index)');
+        DeleteDC = gdi32.func('bool __stdcall DeleteDC(void *hdc)');
+    }
+    catch {
+        CreateDCW = null;
+    }
     // Keep references to registered callbacks to prevent garbage collection
     // These must persist for the entire duration of the native callback invocation
     const __callbackRefs = [];
@@ -139,14 +172,18 @@ async function initializeFFI() {
             return result;
         },
         GetMonitorInfoW: (hMonitor, lpmi) => {
-            // MONITORINFO structure:
+            // MONITORINFOEXW structure:
             // DWORD cbSize (4 bytes)
             // RECT rcMonitor (16 bytes)
             // RECT rcWork (16 bytes)
             // DWORD dwFlags (4 bytes)
-            // Total: 40 bytes
-            const buffer = Buffer.alloc(40);
-            buffer.writeUInt32LE(40, 0); // cbSize
+            // WCHAR szDevice[32] (64 bytes) - the EX part, and the reason for
+            //   asking: the device name is what gdi32 wants to open a DC on
+            //   this monitor, and the only reliable tie from an HMONITOR to a
+            //   \\.\DISPLAYn. cbSize is what selects EX over plain MONITORINFO.
+            // Total: 104 bytes
+            const buffer = Buffer.alloc(104);
+            buffer.writeUInt32LE(104, 0); // cbSize
             const result = GetMonitorInfoW(hMonitor, buffer);
             if (result) {
                 lpmi.cbSize = buffer.readUInt32LE(0);
@@ -163,9 +200,45 @@ async function initializeFFI() {
                     Bottom: buffer.readInt32LE(32),
                 };
                 lpmi.dwFlags = buffer.readUInt32LE(36);
+                const device = buffer.toString('utf16le', 40, 104);
+                const end = device.indexOf('\0');
+                lpmi.szDevice = end >= 0 ? device.substring(0, end) : device;
             }
             return result;
         },
+        GetScaleFactorForMonitor: (hMonitor) => {
+            if (!GetScaleFactorForMonitorRaw)
+                return DEFAULT_SCALE_PERCENT;
+            const scale = Buffer.alloc(4);
+            const hr = GetScaleFactorForMonitorRaw(hMonitor, scale);
+            return hr === 0 ? (scale.readUInt32LE(0) || DEFAULT_SCALE_PERCENT) : DEFAULT_SCALE_PERCENT;
+        },
+        GetPhysicalSizeMm: (deviceName) => {
+            if (!CreateDCW || !deviceName)
+                return null;
+            let hdc = null;
+            try {
+                // An information DC would do, but CreateDCW on the DISPLAY
+                // driver is what every monitor exposes; the caps are the same.
+                hdc = CreateDCW('DISPLAY', deviceName, null, null);
+                if (!hdc)
+                    return null;
+                const width = GetDeviceCaps(hdc, HORZSIZE);
+                const height = GetDeviceCaps(hdc, VERTSIZE);
+                return width > 0 && height > 0 ? { width, height } : null;
+            }
+            catch {
+                return null; // Best-effort: no measurement is not an error
+            }
+            finally {
+                if (hdc) {
+                    try {
+                        DeleteDC(hdc);
+                    }
+                    catch { /* nothing useful to do */ }
+                }
+            }
+        },
     };
 }
 const user32 = await initializeFFI();

package/ignores.txt

@@ -68,6 +68,7 @@ ViewDeferd*
 W
 Widgets
 Windows*
+winpos screen *
 WinUI*
 WISPTIS
 WMS*

package/index.d.ts

@@ -4,9 +4,10 @@
  * Cross-platform Node.js/Bun implementation with FFI
  */
 import { user32, RECT } from './ffi-wrapper.js';
-import { enumerateScreens, sortScreens, ScreenInfo } from './screens.js';
+import { enumerateScreens, sortScreens, screenScale, screenDpi, ScreenInfo } from './screens.js';
 import { enumerateWindows, findWindowsByPattern, WindowInfo, WindowState, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow } from './windows.js';
 import { enumerateTabs, TabInfo, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
+import { showScreenNumbers, OVERLAY_SECONDS, OVERLAY_INCHES } from './screennums.js';
 export interface WindowConfig {
     name: string;
     regex?: boolean;
@@ -23,7 +24,7 @@ export interface WindowConfig {
     maximize?: boolean;
 }
 export type ConfigFile = WindowConfig | WindowConfig[];
-export { RECT, ScreenInfo, WindowInfo, WindowState, TabInfo, enumerateScreens, sortScreens, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, user32 };
+export { RECT, ScreenInfo, WindowInfo, WindowState, TabInfo, enumerateScreens, sortScreens, screenScale, screenDpi, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, showScreenNumbers, OVERLAY_INCHES, OVERLAY_SECONDS, user32 };
 /**
  * Convert screen-relative coordinates to global coordinates
  * @param x - X coordinate relative to screen

package/index.js

@@ -4,15 +4,16 @@
  * Cross-platform Node.js/Bun implementation with FFI
  */
 import { user32 } from './ffi-wrapper.js';
-import { enumerateScreens, sortScreens } from './screens.js';
+import { enumerateScreens, sortScreens, screenScale, screenDpi } from './screens.js';
 import { enumerateWindows, findWindowsByPattern, loadIgnorePatterns, WindowState, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow } from './windows.js';
 import { enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
+import { showScreenNumbers, OVERLAY_SECONDS, OVERLAY_INCHES } from './screennums.js';
 import { join, resolve, isAbsolute } from 'path';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { parse as parseJsonc, printParseErrorCode } from 'jsonc-parser';
 import * as packageJson from './package.json' with { type: 'json' };
 // Re-export public API for library usage
-export { WindowState, enumerateScreens, sortScreens, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, user32 };
+export { WindowState, enumerateScreens, sortScreens, screenScale, screenDpi, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, showScreenNumbers, OVERLAY_INCHES, OVERLAY_SECONDS, user32 };
 // WindowConfig and ConfigFile types are exported from interface definitions above
 // Note: screenPosToPos is exported separately below (after the function definition)
 /**
@@ -178,6 +179,16 @@ function parseArgs(args) {
                         opts.windowTitle = args[i];
                     }
                     break;
+                case 'numsize':
+                    i++;
+                    if (i < args.length) {
+                        const inches = parseFloat(args[i]);
+                        if (inches > 0)
+                            opts.numSize = inches;
+                        else
+                            console.log(`Ignoring -numsize ${args[i]}: expected a size in inches`);
+                    }
+                    break;
                 case 'min':
                     opts.minimize = true;
                     break;
@@ -288,6 +299,7 @@ function applyWindowConfig(config, screensInfo) {
 let dbg = false;
 let dbgVerbose = false; // -dbg flag for detailed output
 let screens = [];
+let numSize = OVERLAY_INCHES; // -numsize: screen-number overlay size in inches
 /**
  * Convert screen-relative coordinates to global coordinates
  * @param x - X coordinate relative to screen
@@ -447,8 +459,19 @@ function listAllWindows(includeIgnored = false) {
     }
     console.log();
     console.log('Command format: tswinpos <title> <x> <y> <screen> [<width> <height>]');
+    // Flash each screen's number on that screen - launched last so the overlays
+    // can't turn up in the listing above. Detached, so we don't wait for them.
+    void showScreenNumbers(screens, OVERLAY_SECONDS, numSize);
 }
 function usage(msg = '') {
+    printUsage(msg);
+    process.exit(1);
+}
+/**
+ * The usage text on its own - no exit, so the no-argument case can print it
+ * while the screen-number overlays are still being launched.
+ */
+function printUsage(msg = '') {
     if (msg)
         console.log(msg);
     console.log('Usage: winpos [options] <title> <x> <y> <screen> [<width> <height>]');
@@ -466,6 +489,7 @@ function usage(msg = '') {
     console.log('  -title name Window title/pattern (alternative to positional)');
     console.log('  -pos x,y[,s] Position (x,y with optional screen index)');
     console.log('  -size w,h   Window size (width,height)');
+    console.log(`  -numsize n  Screen-number overlay size in inches (default ${OVERLAY_INCHES})`);
     console.log('  -min        Minimize window');
     console.log('  -max        Maximize window');
     console.log('  -load file  Load config from JSON/JSONC file (comments + trailing commas OK)');
@@ -474,6 +498,8 @@ function usage(msg = '') {
     console.log('Position/size values can be pixels or percentages (e.g. 50%)');
     console.log('Title can be regex (/pattern/) or prefix (title*)');
     console.log('* = list windows, ** = list all including ignored');
+    console.log(`  (both, like winpos with no arguments, also flash each screen's`);
+    console.log(`   number on that screen for ${OVERLAY_SECONDS} seconds)`);
     console.log();
     console.log('JSON format: {"name":"app","regex":false,"pos":{"x":0,"y":0,"screen":0},"size":{"w":800,"h":600}}');
     console.log('  or array: [{...}, {...}]');
@@ -484,7 +510,6 @@ function usage(msg = '') {
         const screen = screens[i];
         console.log(`${i.toString().padStart(6)} | ${screen.bounds.Left.toString().padStart(5)} ${screen.bounds.Top.toString().padStart(5)} | ${screen.bounds.Width.toString().padStart(5)} ${screen.bounds.Height.toString().padStart(5)}`);
     }
-    process.exit(1);
 }
 export function run(args) {
     // Initialize screens
@@ -506,6 +531,8 @@ export function run(args) {
     // Set debug flags
     dbg = opts.debug;
     dbgVerbose = opts.debugVerbose;
+    if (opts.numSize)
+        numSize = opts.numSize;
     if (dbg)
         console.log('Debug mode enabled.');
     if (dbgVerbose)
@@ -596,6 +623,17 @@ export function run(args) {
         showWindowInfo(posArgs[0]);
         return;
     }
+    // Nothing to act on (bare winpos, or -help): flash each screen's number on
+    // that screen while the usage text - screen table and all - prints, so the
+    // table has something to point at. The overlays time out and close
+    // themselves; we only wait for the launch, because process.exit here would
+    // kill the spawn in mid-flight and no numbers would ever appear.
+    if (posArgs.length === 0) {
+        const overlays = showScreenNumbers(screens, OVERLAY_SECONDS, numSize);
+        printUsage();
+        void overlays.finally(() => process.exit(1));
+        return;
+    }
     if (posArgs.length < 4) {
         usage();
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/winpos",
-  "version": "2.0.50",
+  "version": "2.0.52",
   "description": "TypeScript implementation of winpos - Windows window positioning utility",
   "type": "module",
   "main": "index.js",
@@ -32,6 +32,7 @@
     "@types/node": "^25.3.0"
   },
   "dependencies": {
+    "@bobfrankston/msger": "^0.1.424",
     "jsonc-parser": "^3.3.1",
     "koffi": "^2.9.2"
   },
@@ -45,5 +46,17 @@
   "bugs": {
     "url": "https://github.com/BobFrankston/winpos/issues"
   },
-  "homepage": "https://github.com/BobFrankston/winpos#readme"
+  "homepage": "https://github.com/BobFrankston/winpos#readme",
+  ".dependencies": {
+    "@bobfrankston/msger": "file:../msgx/msger",
+    "jsonc-parser": "^3.3.1",
+    "koffi": "^2.9.2"
+  },
+  ".transformedSnapshot": {
+    "dependencies": {
+      "@bobfrankston/msger": "^0.1.424",
+      "jsonc-parser": "^3.3.1",
+      "koffi": "^2.9.2"
+    }
+  }
 }

package/screennums.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Screen number overlay - briefly flashes each screen's winpos index in the
+ * middle of that screen, so you can see which physical display is screen 0,
+ * screen 1, ... without counting corners.
+ *
+ * Rendered with msger (@bobfrankston/msger). The overlays are detached and
+ * self-closing, so winpos exits immediately and leaves them up.
+ */
+import { type ScreenInfo } from './screens.js';
+/** Default overlay size, in real inches on the glass */
+export declare const OVERLAY_INCHES = 2;
+export declare const OVERLAY_SECONDS = 5;
+/**
+ * Show the index of every screen in the middle of that screen.
+ *
+ * Never throws: the overlay is a convenience, so a missing or unhappy msger
+ * must not break the window listing it accompanies.
+ *
+ * @param screens - Screens in winpos order (the index shown is the array index)
+ * @param seconds - How long each overlay stays up
+ * @param inches - Size of each overlay in real inches, measured on the glass
+ */
+export declare function showScreenNumbers(screens: ScreenInfo[], seconds?: number, inches?: number): Promise<void>;
+//# sourceMappingURL=screennums.d.ts.map

package/screennums.js

@@ -0,0 +1,134 @@
+/**
+ * Screen number overlay - briefly flashes each screen's winpos index in the
+ * middle of that screen, so you can see which physical display is screen 0,
+ * screen 1, ... without counting corners.
+ *
+ * Rendered with msger (@bobfrankston/msger). The overlays are detached and
+ * self-closing, so winpos exits immediately and leaves them up.
+ */
+import { screenDpi, screenScale } from './screens.js';
+/** Default overlay size, in real inches on the glass */
+export const OVERLAY_INCHES = 2;
+export const OVERLAY_SECONDS = 5;
+// Guard rails for the computed window size, in case a driver's reported
+// dimensions survive the DPI sanity check but still make no sense.
+const MIN_CARD = 80;
+const MAX_CARD = 1200;
+/**
+ * Overlay size in logical pixels so it measures `inches` on that panel.
+ *
+ * Pixels are not a length: the same 360-pixel square is 3.9 inches on a 93 DPI
+ * 32" 1440p panel and 2.2 inches on a 160 DPI 28" 4K one. Going through the
+ * screen's true DPI is what makes the number the same physical size on every
+ * monitor. The scale factor divides back out because msger positions and sizes
+ * windows in logical pixels, which Windows then multiplies by that factor.
+ */
+function cardSize(screen, inches) {
+    const dips = (inches * screenDpi(screen)) / screenScale(screen);
+    return Math.round(Math.min(MAX_CARD, Math.max(MIN_CARD, dips)));
+}
+/**
+ * Full page for one overlay - big number, no msger template or buttons.
+ *
+ * Everything is sized in vh so the page fits whatever window the caller asked
+ * for: the window is what carries the physical size, and the digit is simply a
+ * fraction of it.
+ */
+function overlayHtml(index, screen, seconds) {
+    const b = screen.bounds;
+    // Size in winpos's own coordinates - the numbers you'd type at it - plus
+    // the scaling, since that's why they don't match the monitor's spec sheet.
+    const label = [
+        `${b.Width} x ${b.Height}`,
+        screen.scalePercent !== 100 ? `${screen.scalePercent}%` : '',
+        screen.primary ? 'primary' : ''
+    ].filter(Boolean).join(' - ');
+    return `<!doctype html>
+<html><head><meta charset="utf-8"><title>winpos screen ${index}</title>
+<style>
+  html, body { height: 100%; margin: 0; background: transparent; }
+  body {
+    display: flex; align-items: center; justify-content: center;
+    font-family: "Segoe UI", system-ui, sans-serif;
+    user-select: none;
+  }
+  .card {
+    display: flex; flex-direction: column;
+    align-items: center; justify-content: center;
+    width: 100%; height: 100%;
+    box-sizing: border-box;
+    /* Solid black, white digits - the highest-contrast reading of the number.
+       msger's overlay window composites onto white rather than the desktop
+       here, so a translucent background just came out gray; painting it
+       opaque is both clearer and honest about what's actually drawn. */
+    background: #000000;
+    color: #ffffff;
+  }
+  .num { font-size: 62vh; font-weight: 700; line-height: 1; }
+  .label { font-size: 4.5vh; opacity: 0.75; margin-top: 3vh; }
+</style></head>
+<body><div class="card"><div class="num">${index}</div><div class="label">${label}</div></div>
+<script>
+  // The page dismisses itself: msger's own timeout is only checked when the
+  // window sees an event, so an overlay nobody touches sits there forever.
+  // Posting a result over the IPC bridge is what the msger template does for
+  // a button click - it wakes the host, which then exits.
+  setTimeout(() => {
+    if (window.ipc && window.ipc.postMessage)
+      window.ipc.postMessage(JSON.stringify({ button: 'timeout', timeout: true }));
+    else
+      window.close();
+  }, ${Math.round(seconds * 1000)});
+</script>
+</body></html>`;
+}
+/**
+ * Show the index of every screen in the middle of that screen.
+ *
+ * Never throws: the overlay is a convenience, so a missing or unhappy msger
+ * must not break the window listing it accompanies.
+ *
+ * @param screens - Screens in winpos order (the index shown is the array index)
+ * @param seconds - How long each overlay stays up
+ * @param inches - Size of each overlay in real inches, measured on the glass
+ */
+export async function showScreenNumbers(screens, seconds = OVERLAY_SECONDS, inches = OVERLAY_INCHES) {
+    let showMessageBox;
+    try {
+        ({ showMessageBox } = await import('@bobfrankston/msger'));
+    }
+    catch {
+        return; // msger not installed - skip the overlay silently
+    }
+    // All of them are launched at once so the numbers appear together.
+    await Promise.all(screens.map((screen, i) => {
+        const b = screen.bounds;
+        // msger takes its position in device-independent pixels, which it then
+        // scales by the target monitor's DPI. winpos's own coordinates are
+        // already DIPs *within* a monitor, but each monitor's origin is in
+        // physical pixels - so only the origin needs dividing by the scale.
+        // Without this, the overlay on a 125% monitor whose origin is a few
+        // thousand pixels out lands far right of center (5K screen, 768px off).
+        const scale = screenScale(screen);
+        const card = cardSize(screen, inches);
+        const x = b.Left / scale + (b.Width - card) / 2;
+        const y = b.Top / scale + (b.Height - card) / 2;
+        return showMessageBox({
+            title: `winpos screen ${i}`,
+            html: overlayHtml(i, screen, seconds),
+            rawHtml: true, // No msger template, no OK button
+            overlay: true, // Frameless, transparent, click-through, on top
+            size: { width: card, height: card },
+            pos: { x: Math.round(x), y: Math.round(y) },
+            timeout: seconds + 5, // Backstop if the page never runs
+            detach: true, // Outlives winpos itself
+            // Own WebView2 profile per overlay: msger windows sharing one
+            // user-data dir also share a browser process, and starting all of
+            // them at once made that shared process fall over - overlays came
+            // up one at a time and some died early. Separate profiles start in
+            // parallel and are independent.
+            profile: `winpos-screen-${i}`
+        }).catch(() => { });
+    }));
+}
+//# sourceMappingURL=screennums.js.map

package/screens.d.ts

@@ -12,7 +12,30 @@ export interface ScreenInfo {
         Height: number;
     };
     primary: boolean;
+    /** Display scaling of this monitor as a percent: 100, 125, 150... */
+    scalePercent: number;
+    /** Physical panel size in millimetres (EDID), when the driver reports it */
+    physicalMm?: {
+        width: number;
+        height: number;
+    };
 }
+/** Display scaling of a screen as a factor (1.25 for a 125% display) */
+export declare function screenScale(screen: ScreenInfo): number;
+/** What CSS assumes an inch is, and what Windows calls 100% scaling */
+export declare const NOMINAL_DPI = 96;
+/**
+ * True pixels-per-inch of a screen, measured from the panel's physical size.
+ *
+ * Not the same thing as the scale factor: scaling is a preference, so a 28"
+ * 4K panel left at 100% reports 96 DPI while actually being 160. Anything
+ * sized in pixels - or in CSS inches, which are just 96 pixels - therefore
+ * comes out a different physical size on each monitor.
+ *
+ * Falls back to nominal (96 x scale) when the driver won't say, which is the
+ * old pixel-sized behaviour.
+ */
+export declare function screenDpi(screen: ScreenInfo): number;
 export declare function enumerateScreens(): ScreenInfo[];
 export declare function sortScreens(screens: ScreenInfo[]): ScreenInfo[];
 //# sourceMappingURL=screens.d.ts.map

package/screens.js

@@ -1,7 +1,38 @@
 /**
  * Screen management - enumerate and sort displays
  */
-import { user32, isBun, MONITORINFOF_PRIMARY } from './ffi-wrapper.js';
+import { user32, isBun, MONITORINFOF_PRIMARY, DEFAULT_SCALE_PERCENT } from './ffi-wrapper.js';
+/** Display scaling of a screen as a factor (1.25 for a 125% display) */
+export function screenScale(screen) {
+    return (screen.scalePercent || DEFAULT_SCALE_PERCENT) / 100;
+}
+/** What CSS assumes an inch is, and what Windows calls 100% scaling */
+export const NOMINAL_DPI = 96;
+// A real monitor outside this range means the driver lied about its size
+// (some report the whole video wall, projectors report nothing sensible).
+const MIN_PLAUSIBLE_DPI = 30;
+const MAX_PLAUSIBLE_DPI = 700;
+/**
+ * True pixels-per-inch of a screen, measured from the panel's physical size.
+ *
+ * Not the same thing as the scale factor: scaling is a preference, so a 28"
+ * 4K panel left at 100% reports 96 DPI while actually being 160. Anything
+ * sized in pixels - or in CSS inches, which are just 96 pixels - therefore
+ * comes out a different physical size on each monitor.
+ *
+ * Falls back to nominal (96 x scale) when the driver won't say, which is the
+ * old pixel-sized behaviour.
+ */
+export function screenDpi(screen) {
+    const scale = screenScale(screen);
+    const mm = screen.physicalMm;
+    if (!mm || mm.width <= 0)
+        return NOMINAL_DPI * scale;
+    // bounds are logical pixels, so undo the scaling to get what the panel
+    // actually lights up - that is what spans those millimetres.
+    const dpi = (screen.bounds.Width * scale) / (mm.width / 25.4);
+    return dpi >= MIN_PLAUSIBLE_DPI && dpi <= MAX_PLAUSIBLE_DPI ? dpi : NOMINAL_DPI * scale;
+}
 export function enumerateScreens() {
     const screens = [];
     let monitorIndex = 0;
@@ -16,8 +47,12 @@ export function enumerateScreens() {
                 const monitorInfo = {};
                 if (user32.GetMonitorInfoW(hMonitor, monitorInfo)) {
                     const rcMonitor = monitorInfo.rcMonitor;
+                    // The driver's own name for this monitor - enumeration
+                    // order is not the DISPLAYn numbering, so a name made up
+                    // from the index would point gdi32 at the wrong panel.
+                    const deviceName = monitorInfo.szDevice || `\\\\.\\DISPLAY${monitorIndex + 1}`;
                     screens.push({
-                        deviceName: `\\\\.\\DISPLAY${monitorIndex + 1}`,
+                        deviceName,
                         bounds: {
                             Left: rcMonitor.Left,
                             Top: rcMonitor.Top,
@@ -27,6 +62,8 @@ export function enumerateScreens() {
                             Height: rcMonitor.Bottom - rcMonitor.Top,
                         },
                         primary: (monitorInfo.dwFlags & MONITORINFOF_PRIMARY) !== 0,
+                        scalePercent: user32.GetScaleFactorForMonitor?.(hMonitor) ?? DEFAULT_SCALE_PERCENT,
+                        physicalMm: user32.GetPhysicalSizeMm?.(deviceName) ?? undefined,
                     });
                     monitorIndex++;
                 }
@@ -53,6 +90,7 @@ export function enumerateScreens() {
                 Height: 1080,
             },
             primary: true,
+            scalePercent: DEFAULT_SCALE_PERCENT,
         });
     }
     // If no screens were found, add a default one
@@ -68,6 +106,7 @@ export function enumerateScreens() {
                 Height: 1080,
             },
             primary: true,
+            scalePercent: DEFAULT_SCALE_PERCENT,
         });
     }
     return screens;