react-x11 2.18.4 → 2.18.6

package/src/nodes/paint.js

@@ -3,7 +3,7 @@
 // window, background first.
 
 import { isPlaced } from '../layouts.js';
-import { Surface } from '../ntk.js';
+import { Surface } from '../offscreen.js';
 import { isPaintedColor } from './boxpaint.js';
 import { DAMAGE_SLOP } from './damage.js';
 import { DRAWN_KINDS } from './kinds.js';

package/src/nodes/scrollable.js

@@ -301,11 +301,11 @@ export const Scrollable = (Base) =>
             // for a `<glarea>` child's move that this pane rides (issue
             // #644): its box claimed nothing, and a pane laid out again may
             // have moved rows the move's copy carries where they were.
-            if (clamped || layoutDiff.ride) outer(vp);
+            if (clamped || layoutDiff.ride) outer(vp, this);
           } else {
-            layoutDiff.sink = (rect) => {
+            layoutDiff.sink = (rect, node) => {
               const clipped = intersectRects(rect, vp);
-              if (clipped) outer(clipped);
+              if (clipped) outer(clipped, node);
             };
           }
           this._claimThumbs(thumbsWere, outer);
@@ -863,8 +863,8 @@ export const Scrollable = (Base) =>
         if (sameThumb(before, after)) continue;
         // a pixel of slop for the rounded corners' antialiasing, as the
         // blit's own thumb repair takes
-        if (before) sink(insetRect(before, -1));
-        if (after) sink(insetRect(after, -1));
+        if (before) sink(insetRect(before, -1), this);
+        if (after) sink(insetRect(after, -1), this);
       }
     }
 

package/src/nodes/scrollblit.js

@@ -970,12 +970,22 @@ export class WindowScrollBlit {
         if (ancestors.has(child)) {
           // on the path down: its solid background under the viewport is
           // translation-invariant, its border ring and corners are not.
-          // The widest side is conservative for a non-uniform border
+          // The widest side is conservative for a non-uniform border.
+          //
+          // Rounded, because that is where the ring ends for what is
+          // inside it: at a fractional scale a 1px border is 1.25 or 1.5
+          // device pixels, and layout puts the children at the rounded
+          // inner edge — so the column the ring reaches a quarter of the
+          // way into is a child's, painted over whole. Tested exactly, that
+          // column refused every blit under a bordered box at 125%, the
+          // scale most Windows laptops run at.
           const bw = resolveBorderWidths(
             child.style ?? EMPTY_STYLE,
             child.direction,
           );
-          const ring = Math.max(bw.top, bw.right, bw.bottom, bw.left);
+          const ring = Math.round(
+            Math.max(bw.top, bw.right, bw.bottom, bw.left),
+          );
           if (ring > 0 && !rectContains(insetRect(child.abs, ring), vp)) {
             return false;
           }

package/src/nodes/text.js

@@ -2,7 +2,7 @@
 // selection paints, and the glyph strip.
 
 import { localTextStyleChanged, TEXT_REMEASURE } from '../styles.js';
-import { cssColorStraight } from 'ntk';
+import { cssColorStraight } from 'ntk/color';
 import { hooks as a11yHooks } from '../a11y.js';
 import { codePointAtOffset, codeUnitOffsets } from '../textrange.js';
 import { NO_DAMAGE } from './damage.js';

package/src/nodes/window/capabilities.js

@@ -1,7 +1,7 @@
 // What a window can paint: compositing and ARGB transparency, the window
 // background, and the capabilities `@supports` blocks read.
 
-import { cssColorStraight } from 'ntk';
+import { cssColorStraight } from 'ntk/color';
 import {
   argbVisual,
   compositingActive,

package/src/nodes/window/flush.js

@@ -6,7 +6,7 @@ import { resolveFramePolicy } from '../../pacing.js';
 import { paintCacheFor } from '../../paintcache.js';
 import { hooks as traceHooks } from '../../trace-registry.js';
 import { now } from '../animation.js';
-import { FULL_DAMAGE, layoutDiff, addDamageRect } from '../damage.js';
+import { FULL_DAMAGE, layoutDiff } from '../damage.js';
 import { BLIT_POISONED } from '../scrollblit.js';
 import { debugPaint } from './debugpaint.js';
 
@@ -204,12 +204,10 @@ export class WindowFlush {
         (panes && this._paneDamage !== FULL_DAMAGE)
       ) {
         const cap = this._damageRectCap();
-        layoutDiff.sink = (rect) => {
-          if (this._damage !== FULL_DAMAGE) {
-            layoutMoved = true;
-            this._damage = addDamageRect(this._damage, rect, cap);
-          }
-          if (panes) this._addPaneDamage(rect);
+        // each to the lists that paint the node that moved
+        // (`_claimLayoutMove`): a move inside a `<glarea>` is its panes'
+        layoutDiff.sink = (rect, node) => {
+          if (this._claimLayoutMove(rect, node, cap)) layoutMoved = true;
         };
       }
       try {
@@ -259,14 +257,8 @@ export class WindowFlush {
         if (sv && !sv._recordBlitClaim(after)) {
           sv._pendingBlitFrom = BLIT_POISONED;
         }
-        if (this._damage !== FULL_DAMAGE) {
-          this._damage = addDamageRect(
-            this._damage,
-            after,
-            this._damageRectCap(),
-          );
-        }
-        if (panes) this._addPaneDamage(after);
+        // to the lists that paint it, as the layout diff's claims go
+        this._claimLayoutMove(after, node, this._damageRectCap());
       }
       this._reflowed.clear();
     } else if (this._reflowed.size) {
@@ -326,9 +318,26 @@ export class WindowFlush {
     // list was still taken (its bookkeeping is what keeps the two paths one
     // code) and is simply not consumed; the presenter diffs at the layer.
     if (typeof this.window.presentFrame === 'function') {
-      // the panes are no presenter's: they paint from their damage either way
-      if (this._overlaid.size !== 0) this._paintOverlays(paneDamage);
-      this.window.presentFrame(this, damage);
+      // A presenter whose frame is the ordinary paint walk — a pass per
+      // damage rect into a context, the Windows window's — paints through
+      // the paint cache as an ntk window does, and says so
+      // (`usesPaintCache`). Without it every `<canvas cacheKey>` drew
+      // afresh in every pass that reached it, and a shadow, which is only
+      // ever baked into the cache (issue #413), was not drawn at all. The
+      // retained layer presenter paints nodes onto layers of their own and
+      // keeps to itself.
+      const cache = this.window.usesPaintCache
+        ? (this._paintCache ??= paintCacheFor(this.app))
+        : null;
+      cache?.beginFrame();
+      try {
+        // the panes are no presenter's: they paint from their damage either
+        // way
+        if (this._overlaid.size !== 0) this._paintOverlays(paneDamage);
+        this.window.presentFrame(this, damage);
+      } finally {
+        cache?.endFrame();
+      }
       this.app._reactX11Startup?.painted();
       return true;
     }

package/src/ntk.js

@@ -22,43 +22,20 @@
 // `@react-x11/components` (`<Markdown>`, `<Formula>`). `SvgView` is still
 // here; a drawing is not a document.
 //
-// One name is not a plain re-export. `Surface` below asks the app it is
+// One name is not a plain re-export. `Surface` (src/offscreen.js) asks the app it is
 // handed for the implementation, because ntk's own is a pixmap and a
 // Picture — an X connection's — and a component allocates its buffer
 // without knowing which backend it was mounted on. This subpath is where a
 // drawing-adjacent name gets its backend-neutral answer; the X-only names
 // (`createClient`, `Pixmap`, `Picture`, `XEmbedSocket`) stay X-only.
-import { Surface as NtkSurface } from 'ntk';
+import * as ntk from 'ntk';
+
+import { adoptNtk } from './ntkroot.js';
 
 export * from 'ntk';
 export { default } from 'ntk';
+export { Surface } from './offscreen.js';
 
-/**
- * ntk's offscreen `Surface`, on whichever backend `app` is.
- *
- * An app that makes its own surfaces answers `createSurface(options)` —
- * the Cocoa app does, over a CG bitmap (src/cocoa/surface.js), the Wayland
- * app over a GL render target (src/wayland/surface.js) — and an ntk
- * connection has no such method and gets ntk's pixmap. The result is
- * whichever implementation answered, not an instance of this class: the
- * contract is the shape — `width`/`height`, `getContext('2d')`, `render`,
- * `clear`, `copyWithin`, `destroy`, and `ctx.drawImage(surface, …)` —
- * (docs/extending.md "Scrolling the pixels, not just the offset"), and
- * nothing needs `instanceof`.
- *
- * Part of that shape is that a context may be **held**: ntk tells a caller
- * doing many draws to take `getContext('2d')` once rather than one per
- * frame, and that holds on every backend here, including the ones where a
- * surface is a GPU target sharing a device with the window (#566). Draws
- * through a held context land in the surface whenever they are made, and
- * leave nothing for the caller to restore; `render(fn)` is the scoped form,
- * for a caller that wants a frame's clean transform and clip.
- */
-export class Surface {
-  constructor(app, options) {
-    if (typeof app?.createSurface === 'function') {
-      return app.createSurface(options);
-    }
-    return new NtkSurface(app, options);
-  }
-}
+// what src/ntkroot.js would load, already loaded: handed over rather than
+// imported twice
+adoptNtk(ntk);

package/src/ntkroot.js

@@ -0,0 +1,50 @@
+// ntk's package root — the X11 client, ntk's windows and their contexts, the
+// GL rungs, fontconfig and the rest of what the X11 backend draws with —
+// loaded where an X connection is made rather than wherever react-x11 is
+// imported.
+//
+// Only that backend needs it. The Cocoa, Windows and Wayland backends use a
+// colour parser, the shadow arithmetic, the image and SVG decoders and the
+// font parser of ntk's, each from a subpath of its own (`ntk/color`,
+// `ntk/shadow-math`, `ntk/image`, `ntk/svg`, `ntk/font`, …), and importing
+// the root for them was ~210 ms of module loading on Windows before the first
+// window of an app that never opens an X connection.
+//
+// `createRoot` loads it on the X11 path, before the connection, and for an
+// ntk app it is handed rather than makes — an app that could only have come
+// from ntk's own `createClient`, so the import is already done and this is a
+// lookup. `react-x11/ntk` hands over the root it imports. After that, the
+// code that only ever runs against an X connection reads it synchronously.
+let root = null;
+let loading = null;
+
+/** Load ntk's root, once; resolves to the module. */
+export function loadNtk() {
+  return (loading ??= import('ntk').then((mod) => (root = mod)));
+}
+
+/** A root imported some other way (`react-x11/ntk`): the same module, so
+ *  nothing is loaded twice by taking it. */
+export function adoptNtk(mod) {
+  root ??= mod;
+  loading ??= Promise.resolve(mod);
+}
+
+/** ntk's root, or null while no X connection has been made. */
+export function ntkRoot() {
+  return root;
+}
+
+/**
+ * ntk's root, for code that only runs against an X connection — which
+ * `createRoot` has loaded it for. Throws where it is not: reaching for an X
+ * resource on a backend that has none is the mistake, and this says so
+ * rather than failing inside ntk on an app that is not its own.
+ */
+export function x11Ntk(what) {
+  if (root) return root;
+  throw new Error(
+    `react-x11: ${what} needs an X connection, and this process has none ` +
+      '(ntk loads with the X11 backend, in createRoot).',
+  );
+}

package/src/offscreen.js

@@ -0,0 +1,33 @@
+// An offscreen surface on whichever backend an app is — what the paint cache,
+// a group's opacity and the symbol icons draw into, and what `react-x11/ntk`
+// hands a component as `Surface`.
+//
+// An app that makes its own surfaces answers `createSurface(options)` — the
+// Cocoa app over a CG bitmap (src/cocoa/surface.js), the Windows app over a
+// Direct2D bitmap, the Wayland app over a GL render target
+// (src/wayland/surface.js) — and an X connection has no such method and gets
+// ntk's pixmap, from ntk's root, which only an X connection loads
+// (src/ntkroot.js). The result is whichever implementation answered, not an
+// instance of this class: the contract is the shape — `width`/`height`,
+// `getContext('2d')`, `render`, `clear`, `copyWithin`, `destroy`, and
+// `ctx.drawImage(surface, …)` — (docs/extending.md "Scrolling the pixels, not
+// just the offset"), and nothing needs `instanceof`.
+//
+// Part of that shape is that a context may be **held**: ntk tells a caller
+// doing many draws to take `getContext('2d')` once rather than one per frame,
+// and that holds on every backend here, including the ones where a surface is
+// a GPU target sharing a device with the window (#566). Draws through a held
+// context land in the surface whenever they are made, and leave nothing for
+// the caller to restore; `render(fn)` is the scoped form, for a caller that
+// wants a frame's clean transform and clip.
+import { x11Ntk } from './ntkroot.js';
+
+export class Surface {
+  constructor(app, options) {
+    if (typeof app?.createSurface === 'function') {
+      return app.createSurface(options);
+    }
+    const { Surface: NtkSurface } = x11Ntk('an offscreen surface');
+    return new NtkSurface(app, options);
+  }
+}

package/src/paintcache.js

@@ -42,13 +42,13 @@
 // this package pins, and a named import of something absent is a *load-time*
 // SyntaxError — the whole renderer, not just the cache. Same shape as the
 // `typeof wnd?.scrollRegion !== 'function'` guard for ntk without #139.
-import * as ntk from 'ntk';
 
 // The surface this cache draws into is `react-x11/ntk`'s: ntk's pixmap on
 // an X connection, the app's own (`app.createSurface`) on a backend that
 // makes them — the Cocoa backend's CG bitmap. One import, so the cache
 // names neither.
-import { Surface } from './ntk.js';
+import { ntkRoot } from './ntkroot.js';
+import { Surface } from './offscreen.js';
 
 /** Stale pixels are undebuggable, and every other optimization here has an
  * escape hatch — see NO_SCROLL_BLIT. */
@@ -415,15 +415,19 @@ export class PaintCache {
   }
 }
 
-/** Whether the installed ntk can make the surfaces this needs. Older ones
- * cannot, and the answer is simply that nothing is cached. */
-export const paintCacheSupported = () => typeof ntk.Surface === 'function';
+/** Whether the installed ntk can make the surfaces this needs on an X
+ * connection — ntk's root, which only an X connection loads
+ * (src/ntkroot.js). Older ones cannot, and the answer is simply that nothing
+ * is cached there. */
+export const paintCacheSupported = () =>
+  typeof ntkRoot()?.Surface === 'function';
 
 /** Whether `app` can make an offscreen surface at all: an X connection
  * with the Render extension (ntk's pixmap surface), or a backend with a
  * surface of its own — the Cocoa app's `createSurface` (docs/macos.md). */
 const canMakeSurfaces = (app) =>
-  Boolean(app?.display?.Render) || typeof app?.createSurface === 'function';
+  (Boolean(app?.display?.Render) && paintCacheSupported()) ||
+  typeof app?.createSurface === 'function';
 
 /**
  * The cache for an app, created on first use. Null when caching is off, when
@@ -432,6 +436,6 @@ const canMakeSurfaces = (app) =>
  * there must paint live.
  */
 export function paintCacheFor(app) {
-  if (DISABLED || !paintCacheSupported() || !canMakeSurfaces(app)) return null;
+  if (DISABLED || !canMakeSurfaces(app)) return null;
   return (app._paintCache ??= new PaintCache(app));
 }

package/src/refresh/loader.js

@@ -326,6 +326,28 @@ function buildTransformer({ babel, jsxTransform, refreshTransform }, options) {
 
 let registered = false;
 
+/**
+ * Which files stay out of the hot graph: every package in node_modules,
+ * react-x11's own src/, and whatever the app's `ignore` names.
+ *
+ * Compared with forward slashes, whichever the path arrives with: on
+ * Windows a file path's separators are backslashes, and a forward-slash
+ * test let every package in node_modules into the hot graph — where the
+ * HMR layer's rewrite of a package's modules could leave one reading an
+ * import before it was bound (entities, under htmlparser2).
+ */
+export function hotIgnoreFor(ignore, srcDir = SRC_DIR) {
+  const src = srcDir.replaceAll('\\', '/');
+  return (path) => {
+    const slashed = path.replaceAll('\\', '/');
+    return (
+      slashed.includes('/node_modules/') ||
+      slashed.startsWith(src) ||
+      (ignore ? ignore(path) === true : false)
+    );
+  };
+}
+
 /**
  * Register the hot-reload loader. `react-x11/refresh/register` calls this
  * with no options; a tool that needs the seams writes its own two-line
@@ -362,10 +384,7 @@ export async function registerRefresh(options = {}) {
   const { ignore } = validated;
   registered = true;
 
-  const hotIgnore = (path) =>
-    path.includes('/node_modules/') ||
-    path.startsWith(SRC_DIR) ||
-    (ignore ? ignore(path) === true : false);
+  const hotIgnore = hotIgnoreFor(ignore);
 
   nodeModule.registerHooks({
     load(url, context, nextLoad) {

package/src/screencolor.js

@@ -56,7 +56,7 @@
 // and losing the grab to someone else is detected (the server says so, with
 // a LeaveNotify of mode Ungrab) rather than waited out.
 
-import { pixelLayout, toStraightRgba } from 'ntk';
+import { pixelLayout, toStraightRgba } from 'ntk/imagedata';
 
 import { sessionBus } from './bus.js';
 import { XK_ESCAPE, XK_KP_ENTER, XK_RETURN, XK_SPACE } from './keysyms.js';

package/src/styles.js

@@ -3,7 +3,7 @@
 // Numbers are pixels; strings like '50%' / 'auto' pass through to yoga.
 // The engine is ours (`./yoga.js`) — the enum tables below are built at
 // module scope, which is what that module's synchronous half is for.
-import { cssColorStraight } from 'ntk';
+import { cssColorStraight } from 'ntk/color';
 
 import { parseBoxShadow, parseLinearGradient } from './decorations.js';
 import {

package/src/svgnodes.js

@@ -10,7 +10,7 @@
 // `<Formula>`), composed from public host elements. `<svg>` stays here
 // because it is not a document — it is a drawing, and one node is the right
 // grain for it.
-import { SvgView } from 'ntk';
+import SvgView from 'ntk/svg';
 
 import { Node } from './nodes/node.js';
 import { intrinsicSize } from './nodes/layout.js';

package/src/symbols.js

@@ -17,11 +17,13 @@
 // the same bargain a tray icon's name makes — so an app that runs on both
 // picks its names by platform, as it does for the tray.
 
-import { cssColorStraight, decodeImage, SvgView } from 'ntk';
+import { cssColorStraight } from 'ntk/color';
+import { decodeImage } from 'ntk/image';
+import SvgView from 'ntk/svg';
 import * as nodeFs from 'node:fs';
 
 import { IconTheme } from './icontheme.js';
-import { Surface } from './ntk.js';
+import { Surface } from './offscreen.js';
 import { xsettings } from './xsettings.js';
 
 /** A `fontWeight` as the number both icon systems configure with. */

package/src/trayhooks.js

@@ -54,7 +54,7 @@
 // frame is not available for anything that has to ask the desktop.
 
 import { useEffect, useRef, useState } from 'react';
-import { decodeImage } from 'ntk';
+import { decodeImage } from 'ntk/image';
 
 import { useAppOrNull } from './appcontext.js';
 import { currentRegistration } from './application.js';

package/src/wayland/context2d.js

@@ -42,7 +42,8 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { Path2D, Image as NtkImage } from 'ntk';
+import { Image as NtkImage } from 'ntk/image';
+import { Path2D } from 'ntk/path';
 import { glDevice } from './device.js';
 import { GlyphAtlas } from './glyphatlas.js';
 import { GLTarget } from './target.js';

package/src/wayland/decorations.js

@@ -32,7 +32,7 @@
 // buttons do what they say. input.js routes; this answers where things are.
 
 import fs from 'node:fs';
-import { Path2D } from 'ntk';
+import { Path2D } from 'ntk/path';
 import { RESIZE_EDGE, TOPLEVEL_STATE } from './window.js';
 import { DEFAULTS, parseButtonLayout, titleFont } from './framestyle.js';
 

package/src/win32/a11y.js

@@ -36,6 +36,22 @@ import { onApp } from '../trace-registry.js';
 
 const TRACE = process.env.REACT_X11_TRACE_A11Y === '1';
 
+/**
+ * How often commits may push the mirror, in ms. A commit that follows a
+ * quiet spell pushes at once; a stream of them — a pan, a drag, a value
+ * ticking — pushes once per interval, the last of them catching up.
+ *
+ * UIA's clients are almost always listening on a desktop Windows (the
+ * touch keyboard, the text services and others ask for the tree), so the
+ * push is not the rare case the listening gate makes it elsewhere: a walk
+ * of the window and a marshalled diff, on every commit. For a graph pane
+ * whose every item moves on every step of a pan that was 1.6 ms of each
+ * frame. A screen reader reads positions on demand and does not need
+ * sixty of them a second; a focus change, which it is waiting on, still
+ * pushes at once (`hooks.focus`), as does an announcement.
+ */
+const COMMIT_PUSH_MS = 100;
+
 // --------------------------------------------------------------------------
 // The one translation that is Windows' own
 // --------------------------------------------------------------------------
@@ -300,6 +316,9 @@ export class Win32Accessibility {
     this._pushed = new Set();
     this._unsubscribes = [];
     this.dead = false;
+    /** When a commit last pushed, and the push a stream of commits owes. */
+    this._lastCommitPush = -Infinity;
+    this._trailing = null;
   }
 
   _idOf(node) {
@@ -388,15 +407,29 @@ export class Win32Accessibility {
    * commit and paying nothing — the same shape as the AT-SPI bridge's "no
    * bus, no work".
    *
+   * *Nobody* is asked per window where the bridge can say (`uiaActive`):
+   * whether a client has read this window's tree in the last few seconds.
+   * UIA's own answer, `UiaClientsAreListening`, is whether any client on
+   * the desktop is subscribed to anything, and on a Windows running the
+   * touch keyboard or the text services that is always yes — so every
+   * commit walked and diffed the window for a mirror nobody read. A client
+   * that comes back after a quiet spell is noticed on its first read and
+   * asks for a fresh push (`wanted`). `global` keeps the desktop-wide answer
+   * for a focus change and an announcement: a client subscribed to focus
+   * events reads the focused element the moment it hears of it, before
+   * any read of ours could say it was there.
+   *
    * With one exception, which is what makes the gate safe: **every window is
    * pushed once regardless.** A client's first `WM_GETOBJECT` has to find a
    * tree, and it arrives before anything in this process knows a client
    * exists. After that first push the mirror is live, and a client attaching
    * later asks for a fresh one (`uia-wanted`).
    */
-  flush({ force = false } = {}) {
+  flush({ force = false, global = false } = {}) {
     if (this.dead || this._dirty.size === 0) return;
-    const listening = force || this._native.uiaListening();
+    const perWindow =
+      !force && !global && typeof this._native.uiaActive === 'function';
+    const listening = force || (!perWindow && this._native.uiaListening());
     const windows = [...this._dirty];
     this._dirty.clear();
     for (const win of windows) {
@@ -409,12 +442,37 @@ export class Win32Accessibility {
         this._dirty.add(win);
         continue;
       }
-      if (!listening && this._pushed.has(wnd.id)) continue;
+      if (
+        !listening &&
+        this._pushed.has(wnd.id) &&
+        !(perWindow && this._native.uiaActive(wnd.id))
+      ) {
+        continue;
+      }
       this._pushed.add(wnd.id);
       this._push(win);
     }
   }
 
+  /** A commit's push, at most once per `COMMIT_PUSH_MS`. */
+  _commitFlush() {
+    if (this.dead || this._dirty.size === 0) return;
+    const now = performance.now();
+    const wait = this._lastCommitPush + COMMIT_PUSH_MS - now;
+    if (wait <= 0) {
+      this._lastCommitPush = now;
+      this.flush();
+      return;
+    }
+    if (this._trailing) return;
+    this._trailing = setTimeout(() => {
+      this._trailing = null;
+      this._lastCommitPush = performance.now();
+      this.flush();
+    }, wait);
+    this._trailing.unref?.();
+  }
+
   /** A window's HWND exists now, so what is owed for it can be pushed. */
   windowReady(wnd) {
     const win = this.toplevels.find((w) => w.window === wnd);
@@ -546,12 +604,12 @@ export class Win32Accessibility {
       // Pushed now rather than at the next commit: a focus change is what a
       // screen reader is waiting for, and the event has to follow an update
       // that already carries the new state or the client reads the old one.
-      this.flush();
+      this.flush({ global: true });
       const wnd = this._windowOf(win);
       if (wnd && next) this._native.uiaFocusChanged(wnd.id, this._idOf(next));
     };
     hooks.windowFocus = (win) => this._dirty.add(win);
-    hooks.commit = () => this.flush();
+    hooks.commit = () => this._commitFlush();
     hooks.announce = (text, opts) => {
       const win =
         this.toplevels.find((w) => w.events?.windowFocused) ??
@@ -562,7 +620,7 @@ export class Win32Accessibility {
       // The window must be in the mirror before anything can be announced
       // from it, which on the first announcement of a session it may not be.
       this._dirty.add(win);
-      this.flush();
+      this.flush({ global: true });
       return Boolean(
         this._native.uiaAnnounce(wnd.id, String(text), !opts?.assertive),
       );
@@ -579,6 +637,8 @@ export class Win32Accessibility {
   bury() {
     if (this.dead) return;
     this.dead = true;
+    if (this._trailing) clearTimeout(this._trailing);
+    this._trailing = null;
     for (const key of Object.keys(hooks)) hooks[key] = null;
     for (const unsubscribe of this._unsubscribes) unsubscribe();
     this._unsubscribes = [];