react-x11 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-x11",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "react renderer with X11 as a target",
   "main": "./src/index.js",
   "files": [
@@ -49,6 +49,7 @@
     "examples:foreign": "tsx examples/foreign.jsx",
     "examples:frame": "tsx examples/frame.jsx",
     "labs:text-baseline": "tsx examples/labs/text-baseline.jsx",
+    "labs:direct-gl": "tsx examples/labs/direct-gl.jsx",
     "examples:viewer3d": "tsx examples/viewer3d.jsx",
     "examples:transparent": "tsx examples/transparent.jsx",
     "examples:windows": "tsx examples/windows.jsx",
@@ -82,7 +83,7 @@
     "node": ">=20.19"
   },
   "dependencies": {
-    "ntk": "^8.3.0",
+    "ntk": "^8.4.0",
     "react-reconciler": "^0.33.0",
     "yoga-layout": "^3.2.1"
   },
@@ -90,10 +91,10 @@
     "dbus-native": "^0.15.1"
   },
   "peerDependencies": {
-    "react": "^19.0.0",
     "@babel/core": "^8.0.0",
     "@babel/plugin-transform-react-jsx": "^8.0.0",
     "hot-module-replacement": "^4.0.1",
+    "react": "^19.0.0",
     "react-refresh": "^0.18.0"
   },
   "peerDependenciesMeta": {

package/src/components/Checkbox.js

@@ -5,7 +5,7 @@
 import React from 'react';
 import { changeEvent } from './change.js';
 import { Icon } from './Icon.js';
-import { labelContent, useControl, useTheme } from './theme.js';
+import { focusRingStyle, labelContent, useControl, useTheme } from './theme.js';
 
 const h = React.createElement;
 
@@ -52,18 +52,28 @@ export function Checkbox({
       : hover
         ? theme.accentHover
         : theme.accent;
-  // An empty well has no fill to step, so it shows the two states in two
-  // different places: hovering firms the ring up, and pressing greys the
-  // inside as well. Three looks, which is the point — a hover the press
-  // cannot be told apart from says nothing about the press.
+  // An empty well has no fill to step, so it shows its states in two
+  // different places: focus is a *colour* on the border, hover and press are
+  // a *step* of the inside. Three looks, which is the point — a hover the
+  // press cannot be told apart from says nothing about the press — and four
+  // with focus, because the two channels compose instead of overwriting.
+  //
+  // They used to share the border, where hover won, and that made the focus
+  // colour unreachable by the gesture that focuses by pointer: a click ends
+  // with the pointer sitting on the control it just focused, so the well was
+  // hover-grey for as long as the user was looking at it and only turned
+  // blue once they moved the mouse away.
   const empty = {
-    borderColor:
-      pressed || hover
+    borderColor: focused
+      ? theme.borderFocus
+      : pressed || hover
         ? theme.textMuted
-        : focused
-          ? theme.borderFocus
-          : theme.border,
-    backgroundColor: pressed ? theme.surfaceActive : theme.surface,
+        : theme.border,
+    backgroundColor: pressed
+      ? theme.surfaceActive
+      : hover
+        ? theme.surfaceHover
+        : theme.surface,
   };
   return h(
     'box',
@@ -91,6 +101,9 @@ export function Checkbox({
           backgroundColor: checked ? fill : empty.backgroundColor,
           alignItems: 'center',
           justifyContent: 'center',
+          // a checked well is filled with the accent, so the border tier
+          // above has nothing left to say — see {@link focusRingStyle}
+          ...focusRingStyle(theme, checked && focused),
         },
       },
       checked &&

package/src/components/Radio.js

@@ -4,7 +4,7 @@
 
 import React, { useContext, useEffect, useMemo, useRef } from 'react';
 import { changeEvent } from './change.js';
-import { labelContent, useControl, useTheme } from './theme.js';
+import { focusRingStyle, labelContent, useControl, useTheme } from './theme.js';
 import { XK_DOWN, XK_LEFT, XK_RIGHT, XK_UP } from './keys.js';
 
 const h = React.createElement;
@@ -109,16 +109,30 @@ export function Radio({ value, children, label, disabled = false }) {
           height: 16,
           borderRadius: 8,
           borderWidth: theme.borderWidth,
+          // Focus on the border, hover and press on the inside — the two
+          // channels Checkbox splits them into, and for the same reason: a
+          // click leaves the pointer on the control, so a focus colour hover
+          // can overwrite is one the pointer user never gets to see.
+          //
+          // A *selected* radio has spent its border on the fill, and the
+          // branch below it was unreachable — the one radio in a group that
+          // can be clicked without changing anything was also the only one
+          // with nothing to show for it. It gets the ring instead.
           borderColor: selected
             ? fill
-            : pressed || hover
-              ? theme.textMuted
-              : focused
-                ? theme.borderFocus
+            : focused
+              ? theme.borderFocus
+              : pressed || hover
+                ? theme.textMuted
                 : theme.border,
-          backgroundColor: pressed ? theme.surfaceActive : theme.surface,
+          backgroundColor: pressed
+            ? theme.surfaceActive
+            : hover
+              ? theme.surfaceHover
+              : theme.surface,
           alignItems: 'center',
           justifyContent: 'center',
+          ...focusRingStyle(theme, selected && focused),
         },
       },
       selected &&

package/src/components/theme.js

@@ -334,6 +334,35 @@ export const capTrim = Object.freeze({ textBoxTrim: 'cap-alphabetic' });
  */
 export const capBand = (fontSize) => Math.round(fontSize * 0.72);
 
+/**
+ * The focus ring, as style, for the one part of a widget that has to draw
+ * its own — or `null`, to be spread away, when it does not.
+ *
+ * Every empty control says focus in its border (`borderFocus`), which is the
+ * `:focus` tier styling.md asks for: a colour change welcome however focus
+ * arrived. A **filled** one — a checked box, a selected radio — has spent
+ * that border on the fill and has no colour left to spend, so it says the
+ * same thing one ring further out instead.
+ *
+ * On the part, not the row. The row already draws core's ring, but that one
+ * is the *keyboard* tier — `:focus-visible`, so it arrives on Tab and not on
+ * a click — and it wraps the label with the well. This is the other tier,
+ * and the two stack the same way the border colour and that ring already do.
+ *
+ * `undefined` for the width when off, never `0`: a node with no
+ * `outlineWidth` of its own is one core can leave out of the widened damage
+ * rects entirely (`_outlineExtent`, src/nodes.js), and `0` is the documented
+ * way to opt *out* of a ring the node would otherwise get.
+ */
+export const focusRingStyle = (theme, on) =>
+  on
+    ? {
+        outlineWidth: theme.focusRingWidth,
+        outlineColor: theme.focusRing,
+        outlineOffset: theme.focusRingOffset,
+      }
+    : null;
+
 /**
  * The geometry of rows on a rounded sheet: how far a row sits inside the
  * sheet's edge, and how round its own corners are.

package/src/events.js

@@ -13,7 +13,12 @@ import { callHandler, reportHandlerError } from './errors.js';
 import { armDrag } from './dnd.js';
 import { desktopSettings } from './desktopsettings.js';
 import { noteInputTime } from './inputtime.js';
-import { hooks as a11yHooks, isFocusable, effectivelyVisible } from './a11y.js';
+import {
+  hooks as a11yHooks,
+  isFocusable,
+  isTextControl,
+  effectivelyVisible,
+} from './a11y.js';
 import { Composer, composeTableFor } from './compose.js';
 import { acceleratorKeysym } from './keyboard.js';
 import { MOD } from './keysyms.js';
@@ -340,6 +345,11 @@ export class EventManager {
     // release that continue the same gesture follow
     this._downDefaulted = false;
     this.capturedNode = null;
+    // The cursor the window is already wearing. `null` rather than
+    // undefined on purpose: `null` *is* a cursor — X None, "inherit the
+    // parent's" — and it is the one a window starts with, so the first
+    // hover over a subtree that names no cursor has nothing to change.
+    this._appliedCursor = null;
     // Attention (ntk#37): the one node the pointer looks like it is heading
     // for, the recent pointer samples the trajectory is estimated from, and
     // the window's candidate registry held directly so the motion path costs
@@ -1497,6 +1507,12 @@ export class EventManager {
    * handing focus back as it closes, `node.focus()` from an application —
    * lights one, because none of those tell the user where focus went.
    *
+   * With one exception, which is CSS's too: a **text control** clicked into
+   * lights a ring anyway (`_ringsOnPress`). What the pointer user knows is
+   * where they clicked, not that the next keystroke will land there, and a
+   * clicked field is about to swallow the keyboard — so the one thing the
+   * ring says that the click did not is exactly the thing worth saying.
+   *
    * `backwards` is only meaningful for `reason: 'key'`, and only one element
    * has ever needed it: XEmbed distinguishes a Tab arriving forwards from a
    * back-Tab, because that is what tells an embedded client whether to focus
@@ -1548,7 +1564,10 @@ export class EventManager {
       // and back onto the window that owns it.
       if (!this.keyboardFocused && !restoring) this.node.window?.focus?.();
       node.setStyleState(':focus', true);
-      node.setStyleState(':focus-visible', reason !== 'pointer');
+      node.setStyleState(
+        ':focus-visible',
+        reason !== 'pointer' || this._ringsOnPress(node),
+      );
       // …and nothing scrolls to meet it either: the node is coming back to
       // the arrangement it left, and this reveal's layout has not run, so a
       // scroll here would be computed from a rect that does not exist yet.
@@ -1564,6 +1583,26 @@ export class EventManager {
     a11yHooks.focus?.(old, node);
   }
 
+  /**
+   * Whether a press lands `:focus-visible` on this node as well as `:focus`.
+   *
+   * The UA rule browsers settled on, and for the reason they settled on it:
+   * a control the keyboard is about to talk to has to show that it holds the
+   * keyboard, whichever way focus arrived. Clicking into a field puts the
+   * caret somewhere the user chose and then makes every keystroke go there —
+   * a state a button, a checkbox or a tab does not enter on a click, which
+   * is why those still stay dark until Tab.
+   *
+   * Asked as "does this element hold editable text", not as "is its kind
+   * `<textinput>`": `isTextControl` is the same predicate the AT-SPI
+   * EDITABLE state is built on (src/a11y.js), so `<textarea>` and a
+   * third-party editor reporting an editable text state answer yes on their
+   * own — the two routes that make a node take the keyboard cannot drift.
+   */
+  _ringsOnPress(node) {
+    return isTextControl(node);
+  }
+
   /**
    * Flip `:focus-within` over the focused node's ancestor chain, diffed the
    * way hover and the press chain are.

package/src/nodes.js

@@ -262,6 +262,7 @@ const INVALIDATE_REASONS = new Set([
   'props', // a React commit changed what a node draws
   'style-state', // :hover/:focus/:active/:disabled restyle
   'shadow', // a boxShadow got smaller: where it *was* still owes a repaint
+  'outline', // …and the same for an outline a style swap took away
   'theme', // a theme/token change restyled a subtree
   'direction', // the reading direction moved: sides, glyph order, bar edge
   'animation', // a transition frame
@@ -1707,6 +1708,26 @@ export class Node {
         );
       }
     }
+    // An outline that just got smaller — or went away — owes the same debt,
+    // and it is only ever owed here. Core's own ring rides `:focus-visible`,
+    // where `EventManager.focus` claims the region while the ring is still
+    // on; what arrives through a style swap is the `outlineWidth` escape
+    // hatch (see `_outline`) — an application outlining a node for a reason
+    // of its own, or a widget ringing one *part* of itself, the way
+    // `<Checkbox>` rings its checked well and drops the ring again on blur.
+    if (
+      displayed.outlineWidth !== this.style.outlineWidth ||
+      displayed.outlineOffset !== this.style.outlineOffset
+    ) {
+      const shrank = this._outlineExtent(displayed) - this._outlineExtent();
+      if (shrank > 0) {
+        this.root?.invalidate(
+          false,
+          insetRect(this.paintBounds(), -shrank),
+          'outline',
+        );
+      }
+    }
     return this.style;
   }
 
@@ -3260,8 +3281,7 @@ export class Node {
    * costs nothing until it is asked for — which is once per focused node
    * per frame, not once per node per commit.
    */
-  _outline() {
-    const style = this.style;
+  _outline(style = this.style) {
     const explicit = style.outlineWidth !== undefined;
     if (!explicit && !this._focusableForRing()) return null;
     const theme = this.theme;
@@ -3287,10 +3307,10 @@ export class Node {
    * *erases* a ring is the one case where the state has already flipped
    * back, and `EventManager.focus` claims the region before it does.
    */
-  _outlineExtent() {
-    if (this.style.outlineWidth === undefined && !this.states[':focus-visible'])
+  _outlineExtent(style = this.style) {
+    if (style.outlineWidth === undefined && !this.states[':focus-visible'])
       return 0;
-    const outline = this._outline();
+    const outline = this._outline(style);
     return outline ? outline.width + Math.max(0, outline.offset) : 0;
   }
 

package/src/scale.js

@@ -54,6 +54,23 @@
 //      subtly wrong size everywhere.
 //   6. **1**, the answer X11 shipped with in 1987.
 //
+// Rungs 4 and 5 read hardware, so they are skipped where the connection is
+// not describing hardware, and both cases are servers people really run:
+//
+//   * **XQuartz** composes in macOS *points* and hands X the point space —
+//     the retina lid arrives as 1728x1080, already density-normalised, and
+//     the window server scales it onto the panel afterwards. Inferring a
+//     factor here doubles a size macOS is about to double again. Detected
+//     by the `Apple-WM` extension, exempted exactly like `XWAYLAND` in
+//     `VIRTUAL_OUTPUT_NAME`: the compositor owns scaling, so we do not.
+//   * **A single synthetic output** covering every monitor. XQuartz, Xvfb,
+//     VNC servers and Xephyr answer the RandR walk with one output named
+//     `default` whose CRTC is the *union* of the desktop; two 2560x1440
+//     monitors union to 5120x1440, which rung 5 would read as a retina
+//     panel. Xinerama reports those heads separately, so more heads than
+//     outputs retires rung 5 — see `isUnionOutput`. Rung 4 survives it:
+//     millimetres describe real glass however the pixels were split.
+//
 // A machine can defeat every rung above the last two — the one this was
 // written against does: UTM in retina mode hands the guest the MacBook's
 // full 3456x2168 grid, QEMU's EDID invents millimetres that read as 100dpi,
@@ -269,13 +286,48 @@ export function snapScale(value) {
   return Math.min(3, Math.max(1, Math.round(value * 4) / 4));
 }
 
+/**
+ * Is this RandR output list describing panels, or one synthetic output
+ * covering the whole desktop?
+ *
+ * Servers that never grew a real output model — XQuartz, Xvfb, x11vnc and
+ * TigerVNC, Xephyr, old drivers under `xorg.conf` — answer the RandR walk
+ * with a single output (usually named `default`, always without
+ * millimetres) whose CRTC is the *union* of every monitor attached. On a
+ * desktop with two monitors side by side that union is twice as wide as any
+ * panel in it, and rung 5 reads pixel counts: a pair of 2560x1440 monitors
+ * unions to 5120x1440 and is judged retina-class, which is how a 1x desk
+ * ends up drawing everything at double size.
+ *
+ * Xinerama is the cross-check, and it is free of the same blind spot: the
+ * same servers report the heads individually there, because that is the
+ * only geometry protocol they implement. More heads than outputs means the
+ * output list is not per-panel data, whatever it claims.
+ */
+export function isUnionOutput(outputs, heads) {
+  return (
+    Array.isArray(outputs) &&
+    outputs.length > 0 &&
+    Number.isInteger(heads) &&
+    outputs.length < heads
+  );
+}
+
 /**
  * One monitor's metadata → `{ scale, source, reason }`, using only what the
  * connection reported: pixel geometry, claimed millimetres, EDID. This is
  * rungs 4 and 5 of the ladder for one output; the caller stacks the
  * desktop-configuration rungs above it.
+ *
+ * `perPanel: false` says this record's geometry spans more than one monitor
+ * (`isUnionOutput` above), which retires rung 5 alone: the resolution class
+ * is a statement about *a panel* and means nothing about a union of them.
+ * Rung 4 still answers when it can, because credible millimetres describe
+ * real glass however the pixels were divided up afterwards — a `--setmonitor`
+ * split of one ultrawide is the case that reaches this branch on a server
+ * whose RandR is otherwise perfectly honest.
  */
-export function monitorScaleFromMetadata(monitor) {
+export function monitorScaleFromMetadata(monitor, { perPanel = true } = {}) {
   const mm = classifyMm(monitor, monitor);
   const pxW = monitor.width ?? 0;
   const pxH = monitor.height ?? 0;
@@ -306,7 +358,7 @@ export function monitorScaleFromMetadata(monitor) {
   // grids stay at 1 on purpose — 2560x1440 is the commonest *1x* desk
   // monitor there is, and only millimetres could tell it from a 13" retina
   // lid, which is exactly the data this branch does not have.
-  if (Math.min(pxW, pxH) >= 1800 || Math.max(pxW, pxH) >= 3000) {
+  if (perPanel && (Math.min(pxW, pxH) >= 1800 || Math.max(pxW, pxH) >= 3000)) {
     return {
       scale: 2,
       source: 'resolution',
@@ -316,7 +368,10 @@ export function monitorScaleFromMetadata(monitor) {
   return {
     scale: 1,
     source: 'default',
-    reason: `no credible density data (mm ${mm}, ${pxW}x${pxH})`,
+    reason: perPanel
+      ? `no credible density data (mm ${mm}, ${pxW}x${pxH})`
+      : `${pxW}x${pxH} spans several monitors, so its pixel count says ` +
+        `nothing about any panel (mm ${mm})`,
   };
 }
 
@@ -468,6 +523,57 @@ async function readOutputs(app) {
   return connected.length ? connected : null;
 }
 
+/**
+ * How many monitors Xinerama says are attached, or null where the server
+ * does not answer. Read only to sanity-check the RandR walk against
+ * (`isUnionOutput`) — the geometry itself is `screens.js`'s business.
+ *
+ * A server with the extension present but inactive replies with one screen
+ * covering everything, which is the same answer as "one monitor" and is
+ * treated as such: the cross-check needs a *disagreement* to fire.
+ */
+async function countHeads(app) {
+  const xinerama = await requireExtension(app, 'xinerama');
+  if (!xinerama?.QueryScreens) return null;
+  const screens = await call(xinerama.QueryScreens.bind(xinerama));
+  return Array.isArray(screens) && screens.length ? screens.length : null;
+}
+
+/**
+ * Is this XQuartz?
+ *
+ * It matters because XQuartz is not handing us a framebuffer: macOS composes
+ * the desktop in *points* and hands X the point space, already normalised
+ * for density. A 16" retina lid arrives as 1728x1080 and a 1x desk monitor
+ * beside it as 2560x1403 — the same 14pt text is the same physical size on
+ * both, and the window server scales what it is given onto whichever panel
+ * the window lands on. Every hardware rung below is therefore answering a
+ * question that was already answered: inferring 2x from the pixels would
+ * double a size macOS is about to double again.
+ *
+ * This is the `XWAYLAND` exemption in `VIRTUAL_OUTPUT_NAME` for the same
+ * reason and by the same rule — the compositor owns scaling, so we do not —
+ * and it sits below the configured rungs, not above them, because a person
+ * who typed `REACT_X11_SCALE` or `GDK_SCALE` outranks the platform.
+ *
+ * `Apple-WM` is the extension quartz-wm drives; it is present on every
+ * XQuartz server and on no other X server, including when the client is
+ * remote and only the display is a Mac (which is exactly when the point
+ * space is still the truth).
+ */
+function isQuartzServer(X) {
+  if (typeof X?.QueryExtension !== 'function') return Promise.resolve(false);
+  return new Promise((resolve) => {
+    try {
+      X.QueryExtension('Apple-WM', (err, reply) =>
+        resolve(!err && !!reply?.present),
+      );
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
 // --------------------------------------------------------------------------
 // The session
 // --------------------------------------------------------------------------
@@ -555,11 +661,35 @@ export async function beginScale(app, option) {
     return session;
   }
 
-  // Rungs 4-5: the hardware, one verdict per output.
-  const outputs = await readOutputs(app);
+  // Rungs 4-5: the hardware, one verdict per output — but only where the
+  // connection is describing hardware. The three reads go out together
+  // because none of them depends on another and this is the chain the first
+  // window waits behind.
+  const [quartz, outputs, heads] = await Promise.all([
+    isQuartzServer(X),
+    readOutputs(app),
+    countHeads(app),
+  ]);
+
+  if (quartz) {
+    // 1, and not because nothing answered: macOS already did the scaling.
+    session.source = 'xquartz';
+    trace(
+      '1x from Apple-WM — XQuartz hands X macOS point space, already scaled',
+    );
+    return session;
+  }
+
+  const perPanel = !isUnionOutput(outputs, heads);
   if (outputs) {
+    if (!perPanel) {
+      trace(
+        `${outputs.length} RandR output(s) against ${heads} Xinerama heads: ` +
+          'the output list is not per-panel, so the resolution class is out',
+      );
+    }
     for (const monitor of outputs) {
-      const verdict = monitorScaleFromMetadata(monitor);
+      const verdict = monitorScaleFromMetadata(monitor, { perPanel });
       session.monitors.set(monitor.name, {
         scale: verdict.scale,
         source: verdict.source,

package/src/screens.js

@@ -401,9 +401,6 @@ function watchLayout(session) {
   const X = session.app.X;
   const root = X.display?.screen?.[0]?.root;
   if (root == null) return;
-  // PropertyChange on a window we do not own. Legal and shared — every
-  // panel-aware application on the desktop selects this same event.
-  X.ChangeWindowAttributes(root, { eventMask: PROPERTY_CHANGE_MASK }, () => {});
   session.onEvent((ev) => {
     if (session.stopped) return;
     if (ev.type !== PROPERTY_NOTIFY || ev.wid !== root) return;
@@ -411,6 +408,27 @@ function watchLayout(session) {
     relayout(session);
   });
   watchRandR(session);
+  // PropertyChange on a window we do not own. Legal and shared — every
+  // panel-aware application on the desktop selects this same event.
+  //
+  // Through ntk's root Window rather than as a raw ChangeWindowAttributes,
+  // because an X event mask is absolute per client: whoever writes last wins
+  // outright. ntk keeps selections additive by tracking the mask on a Window
+  // it caches per id, and adopting the root — which the shared-glyph
+  // directory does to hear MANAGER announcements — starts that tracked mask
+  // at zero and writes StructureNotify over whatever was there. A raw write
+  // is a value the next adopter silently overwrites, in either direction:
+  // reversed, it is a window manager's SubstructureRedirect that goes.
+  //
+  // Last in this function on purpose. `rootWindow()` constructs a Window,
+  // which can throw, and `beginScreens` calls this inside a bare catch — so
+  // ahead of the two registrations above, a throw here would take the
+  // work-area handler and the RandR watch with it rather than only the
+  // selection it belongs to.
+  session.app
+    .rootWindow()
+    .selectInput(PROPERTY_CHANGE_MASK)
+    .catch(() => {});
 }
 
 /** Re-read everything the layout is built from and publish once. */

package/src/windowstate.js

@@ -43,6 +43,7 @@ import { useTopLevelWindow, windowIdOf } from './windowid.js';
 
 const VISIBILITY_NOTIFY = 15;
 const VISIBILITY_CHANGE_MASK = 65536; // x11.eventMask.VisibilityChange
+const PROPERTY_CHANGE_MASK = 4194304; // x11.eventMask.PropertyChange
 const FULLY_OBSCURED = 2;
 const DESKTOP_PROPERTY = '_NET_WM_DESKTOP';
 
@@ -198,6 +199,23 @@ function arm(session) {
   if (!wnd) return;
   session.armed = true;
 
+  // **One selection for everything this session needs.** Two masks are at
+  // stake — PropertyChange for `_NET_WM_STATE`/`_NET_WM_DESKTOP`, and
+  // VisibilityChange for the obscured watch — and ntk grows a window's mask
+  // one request per first listener of each kind. Asking for both here, before
+  // either subscription, makes the `statechange` listener below a detected
+  // no-op and leaves `watchVisibility` nothing to select: one
+  // ChangeWindowAttributes for a session instead of two, on a window that is
+  // already mapped and on screen by the time any of this runs.
+  if (typeof wnd.selectInput === 'function') {
+    Promise.resolve(
+      wnd.selectInput(PROPERTY_CHANGE_MASK | VISIBILITY_CHANGE_MASK),
+    ).catch(() => {
+      // a window destroyed between the ref resolving and this call; the
+      // defaults stand and nothing further will arrive
+    });
+  }
+
   // Focus, from the event manager rather than from ntk directly: it already
   // dedups FocusIn/FocusOut and already knows the answer for a window that
   // has not seen either yet.
@@ -269,9 +287,9 @@ function readDesktop(session) {
 
 /**
  * VisibilityNotify, which ntk has no event name for — its mask table stops
- * at the events a widget toolkit needs — so the mask goes on through
- * `selectInput` (which ORs into ntk's own tracked mask, so nothing it adds
- * later drops this) and the event is read off the raw connection.
+ * at the events a widget toolkit needs — so the event is read off the raw
+ * connection. The mask it needs was selected by `arm()`, together with the
+ * one the state watch needs.
  */
 function watchVisibility(session) {
   const wnd = session.node.window;
@@ -285,11 +303,6 @@ function watchVisibility(session) {
   };
   X.on('event', onEvent);
   session._offs.push(() => X.off?.('event', onEvent));
-
-  Promise.resolve(wnd.selectInput(VISIBILITY_CHANGE_MASK)).catch(() => {
-    // a window destroyed between the ref resolving and this call; the
-    // defaults stand and nothing further will arrive
-  });
 }
 
 /** What is known about a window right now. Stable until it changes. */