npm - @bobfrankston/winpos - Versions diffs - 2.0.51 → 2.0.53 - Mend

@bobfrankston/winpos 2.0.51 → 2.0.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/screennums.js CHANGED Viewed

@@ -6,13 +6,33 @@
  * Rendered with msger (@bobfrankston/msger). The overlays are detached and
  * self-closing, so winpos exits immediately and leaves them up.
  */
-import { screenScale } from './screens.js';
-const CARD = 260; // Overlay content size in pixels (square)
-const FRAME_W = 16; // Window border added around that content
-const FRAME_H = 46; // Border + title bar
+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;
@@ -26,18 +46,28 @@ function overlayHtml(index, screen, seconds) {
     return `<!doctype html>
 <html><head><meta charset="utf-8"><title>winpos screen ${index}</title>
 <style>
-  html, body { height: 100%; margin: 0; }
+  html, body { height: 100%; margin: 0; background: transparent; }
   body {
-    display: flex; flex-direction: column;
-    align-items: center; justify-content: center;
-    background: #1e1e1e; color: #f0f0f0;
+    display: flex; align-items: center; justify-content: center;
     font-family: "Segoe UI", system-ui, sans-serif;
     user-select: none;
   }
-  .num { font-size: 160px; font-weight: 700; line-height: 1; }
-  .label { font-size: 16px; opacity: 0.65; margin-top: 12px; }
+  .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="num">${index}</div><div class="label">${label}</div>
+<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.
@@ -60,8 +90,9 @@ function overlayHtml(index, screen, seconds) {
  *
  * @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) {
+export async function showScreenNumbers(screens, seconds = OVERLAY_SECONDS, inches = OVERLAY_INCHES) {
     let showMessageBox;
     try {
         ({ showMessageBox } = await import('@bobfrankston/msger'));
@@ -79,16 +110,17 @@ export async function showScreenNumbers(screens, seconds = OVERLAY_SECONDS) {
         // 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 x = b.Left / scale + (b.Width - CARD - FRAME_W) / 2;
-        const y = b.Top / scale + (b.Height - CARD - FRAME_H) / 2;
+        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
-            size: { width: CARD, height: CARD },
+            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
-            alwaysOnTop: true,
             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

package/screens.d.ts CHANGED Viewed

@@ -3,6 +3,14 @@
  */
 export interface ScreenInfo {
     deviceName: string;
+    /**
+     * Which physical monitor this is: EDID id + serial (e.g. GSM7721:106NTKF55597),
+     * the key monitor layouts use. Undefined when the identity could not be read.
+     * 2026-09-24 - Claude Code (Fable 5.1): added with the -screens commands.
+     */
+    id?: string;
+    /** The monitor's friendly name from its EDID, e.g. "LG HDR 5K" */
+    name?: string;
     bounds: {
         Left: number;
         Top: number;
@@ -14,9 +22,28 @@ export interface ScreenInfo {
     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 CHANGED Viewed

@@ -2,10 +2,38 @@
  * Screen management - enumerate and sort displays
  */
 import { user32, isBun, MONITORINFOF_PRIMARY, DEFAULT_SCALE_PERCENT } from './ffi-wrapper.js';
+import { enumerateMonitors } from './monitors.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;
@@ -20,8 +48,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,
@@ -32,6 +64,7 @@ export function enumerateScreens() {
                         },
                         primary: (monitorInfo.dwFlags & MONITORINFOF_PRIMARY) !== 0,
                         scalePercent: user32.GetScaleFactorForMonitor?.(hMonitor) ?? DEFAULT_SCALE_PERCENT,
+                        physicalMm: user32.GetPhysicalSizeMm?.(deviceName) ?? undefined,
                     });
                     monitorIndex++;
                 }
@@ -77,6 +110,26 @@ export function enumerateScreens() {
             scalePercent: DEFAULT_SCALE_PERCENT,
         });
     }
+    // 2026-09-24 - Claude Code (Fable 5.1), at Bob's direction: tag each screen
+    // with the monitor's identity, joined on the adapter name. One identity
+    // mechanism for both halves of winpos: the window layouts and the monitor
+    // layouts name the same panel the same way.
+    try {
+        const byDevice = new Map(enumerateMonitors().map(m => [m.device, m]));
+        for (const screen of screens) {
+            const monitor = byDevice.get(screen.deviceName);
+            if (!monitor)
+                continue;
+            screen.id = monitor.id;
+            screen.name = monitor.name;
+        }
+    }
+    catch (error) {
+        // Justified swallow: identity is decoration here - window positioning
+        // works from bounds alone and always has. The -screens commands call
+        // enumerateMonitors() themselves and report this same error there,
+        // so it is not lost, only deferred to the command that needs it.
+    }
     return screens;
 }
 // Tops within this many pixels are treated as the same row (DPI/rounding noise).