ntk 8.3.0 → 8.3.1

package/lib/app.js

@@ -1,3 +1,4 @@
+import { connectionGone } from './cleanup.js';
 import Clipboard from './clipboard.js';
 import { CursorCache } from './cursor.js';
 import { GLError, backendFor, glCapabilities, glError, resolveGLPolicy } from './gl.js';
@@ -253,6 +254,12 @@ export default class App {
   _probeRefreshRate() {
     this._refreshProbe = null; // in progress; only ever started once
     const X = this.X;
+    // A connection on its way out is one more "no rate to be had". The probe
+    // is started lazily by the first window built on this connection, which
+    // may be one adopted from an event still arriving as it closes — and
+    // node-x11 throws synchronously at a request from then on, where the
+    // event dispatch has no caller to catch it (issue #321).
+    if (connectionGone(X)) return;
     X.require('randr', (err, R) => {
       if (err || !R) return;
       const root = this.display.screen[0].root;

package/lib/cleanup.js

@@ -1,11 +1,27 @@
-// Release a server-side resource, tolerating a connection that is closing or
-// already gone — the X server frees all of a client's resources on disconnect,
-// so there is nothing left to do and nothing worth throwing about. This
-// matters for FinalizationRegistry callbacks, which run after app.close() if
-// wrappers get garbage collected late and have no user code around them to
-// catch.
+/**
+ * Whether a request issued now would throw rather than reach the server.
+ * node-x11 throws *synchronously* ("client is in closing state") once
+ * `close()` has begun, and a destroyed or ended stream is the same state one
+ * step further along.
+ *
+ * The check matters wherever a request is issued from somewhere with no
+ * caller to catch: a FinalizationRegistry callback, a paced frame's timer, or
+ * the X event dispatch itself — events already in the read buffer keep being
+ * delivered after `close()` (issue #321).
+ */
+export function connectionGone(X) {
+  return !!(X._closing || !X.stream || X.stream.destroyed || X.stream.writableEnded);
+}
+
+// Issue requests — typically releasing a server-side resource — tolerating a
+// connection that is closing or already gone. The X server frees all of a
+// client's resources on disconnect, so there is nothing left to do and
+// nothing worth throwing about. This matters wherever the requests have no
+// caller around them to catch: FinalizationRegistry callbacks, which run
+// after app.close() if wrappers get garbage collected late, a paced frame's
+// timer, and the X event dispatch (issue #321).
 export function safeRelease(X, fn) {
-  if (X._closing || !X.stream || X.stream.destroyed || X.stream.writableEnded) return;
+  if (connectionGone(X)) return;
   try {
     fn();
   } catch {

package/lib/window.js

@@ -1,7 +1,7 @@
 import x11 from 'x11';
 
 import { builtin } from './builtin.js';
-import { safeRelease } from './cleanup.js';
+import { connectionGone, safeRelease } from './cleanup.js';
 import Drawable from './drawable.js';
 import { packIcons, unpackIcons } from './imagedata.js';
 import Pixmap from './pixmap.js';
@@ -606,22 +606,34 @@ export default class Window extends Drawable {
       // client chose the visual for (issue #295). They go out in the same
       // batch, so the pair costs one round trip, not two, and `ready` is the
       // wait for both.
-      this._readyPending = 2;
-      X.GetGeometry(this.id, (err, res) => {
-        // A window that was destroyed between the id reaching us and this
-        // request reaching the server answers BadWindow, and there is
-        // nothing to record. `ready` still resolves: adopting a window that
-        // has since gone is ordinary for a window manager, and a wait that
-        // never ends is worse than one that ends with width undefined.
-        this._readyPending--;
-        if (err) this._settleReady();
-        else this._applyGeometry(unpackGeometry(res));
-      });
-      X.GetWindowAttributes(this.id, (err, attrs) => {
-        this._readyPending--;
-        if (!err) this.visualId = attrs.visual;
+      //
+      // Nothing is asked of a connection that is going away: node-x11 throws
+      // synchronously at a request once close() has begun, and adoption
+      // happens from places with no caller to catch — a routed child-event,
+      // XEmbed, the shared glyph cache all build windows from inside the X
+      // event dispatch (issue #321). There is nothing to learn there either,
+      // so `ready` settles with the geometry unknown, the same outcome as a
+      // window destroyed before its reply landed (see the getter).
+      this._readyPending = connectionGone(X) ? 0 : 2;
+      if (this._readyPending) {
+        X.GetGeometry(this.id, (err, res) => {
+          // A window that was destroyed between the id reaching us and this
+          // request reaching the server answers BadWindow, and there is
+          // nothing to record. `ready` still resolves: adopting a window that
+          // has since gone is ordinary for a window manager, and a wait that
+          // never ends is worse than one that ends with width undefined.
+          this._readyPending--;
+          if (err) this._settleReady();
+          else this._applyGeometry(unpackGeometry(res));
+        });
+        X.GetWindowAttributes(this.id, (err, attrs) => {
+          this._readyPending--;
+          if (!err) this.visualId = attrs.visual;
+          this._settleReady();
+        });
+      } else {
         this._settleReady();
-      });
+      }
     }
 
     Window._cacheFor(app).set(this.id, this);
@@ -779,6 +791,12 @@ export default class Window extends Drawable {
     this.on('child-event', (ev) => {
       const eventName = xevents.eventName[ev.type];
       if (!eventName) return;
+      // Events buffered before `close()` keep being dispatched after it, and
+      // a window this client already saw destroyed has no substructure left
+      // to report. Neither is worth building a child for — and the questions
+      // the constructor would ask on the way out are what used to throw into
+      // the dispatcher (issue #321).
+      if (this._destroyed || connectionGone(X)) return;
       const child = new Window(app, { id: ev.wid });
       const ntkev = { ...ev, parent: this, window: child, target: child };
       // wait until we know that we track correct x,y,w,h values
@@ -788,6 +806,9 @@ export default class Window extends Drawable {
     });
 
     this.on('newListener', (name) => {
+      // one of ntk's own handlers going on, not a caller asking for an
+      // event: nothing to arm and nothing to select — see _listenInternal
+      if (this._internalListen) return;
       // Listening for 'close' is the opt-in. WM_DELETE_WINDOW only reaches a
       // client that advertised it in WM_PROTOCOLS — a window manager kills
       // anyone else outright — and having to know that, on top of decoding a
@@ -814,6 +835,13 @@ export default class Window extends Drawable {
       const eventMask = xevents.mask[name];
       if (!eventMask) return;
       if ((eventMask & this.eventMask) === 0) {
+        // A connection on its way out can select nothing, and node-x11 throws
+        // synchronously at a request from then on. This hook runs from
+        // `.on()` — including the calls made while adopting a window from
+        // inside the X event dispatch, where there is no caller to catch it
+        // (issue #321). Before the mask is touched, so it goes on saying what
+        // this connection holds.
+        if (connectionGone(X)) return;
         this.eventMask |= eventMask;
         // the selection can legitimately fail — SubstructureRedirect is
         // one-client-only, so `on('map_request')` is how you find out
@@ -821,14 +849,29 @@ export default class Window extends Drawable {
         // error hook rather than dropping it; selectInput() is the
         // explicit form that hands the error straight back.
         X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, (err) => {
-          if (err) this.app.options.onXError?.(err);
+          if (!err) return;
+          // the request failed as a whole, so the server kept the mask it
+          // had: drop the bits again rather than leave `eventMask` claiming
+          // a selection this connection does not hold. selectInput() trusts
+          // it to decide whether a write can be skipped.
+          this.eventMask &= ~eventMask;
+          this.app.options.onXError?.(err);
         });
       }
     });
 
-    this.on('map', () => (this._mapped = true));
-    this.on('unmap', () => (this._mapped = false));
-    this.on('destroy', () => {
+    // ntk's own bookkeeping listens for the same events an app does, and the
+    // hook above reads a listener as a caller expressing interest and selects
+    // for it. For a window ntk created that is free — StructureNotify is in
+    // the CreateWindow value list already — but for an adopted one the
+    // tracked mask starts at zero and the write is absolute, so it would
+    // replace whatever this connection had selected on a window another
+    // client owns (issue #322). Subscribe past the hook: adopting a window
+    // costs no requests and changes no server-side state, and a caller that
+    // wants these events still asks for them, with on('map') or selectInput.
+    this._listenInternal('map', () => (this._mapped = true));
+    this._listenInternal('unmap', () => (this._mapped = false));
+    this._listenInternal('destroy', () => {
       this._destroyed = true;
       this._forget();
       this._teardownFrame(false); // the server has already taken the window
@@ -842,6 +885,24 @@ export default class Window extends Drawable {
     }
   }
 
+  /**
+   * Attach one of ntk's own handlers without the `newListener` hook reading
+   * it as a caller asking for the event. The hook's job is to turn expressed
+   * interest into a server-side selection; ntk's internal bookkeeping
+   * expresses none — it only wants the events that arrive anyway — and on an
+   * adopted window a selection nobody asked for overwrites another
+   * subsystem's (issue #322). The flag is read synchronously by the hook,
+   * which EventEmitter emits before the listener is stored.
+   */
+  _listenInternal(name, fn) {
+    this._internalListen = true;
+    try {
+      this.on(name, fn);
+    } finally {
+      this._internalListen = false;
+    }
+  }
+
   /**
    * Resolves with this window once its geometry is known — immediately for a
    * window ntk created (it already knows what it asked for), when the
@@ -1098,7 +1159,11 @@ export default class Window extends Drawable {
 
   _handleExpose(ev) {
     if (this._backingValid) {
-      this.X.CopyArea(this._backing.id, this.id, this._presentGc, ev.x, ev.y, ev.x, ev.y, ev.width, ev.height);
+      // an expose can arrive after the connection started closing, and this
+      // runs inside the event dispatch where a throw has no caller (#321)
+      safeRelease(this.X, () => {
+        this.X.CopyArea(this._backing.id, this.id, this._presentGc, ev.x, ev.y, ev.x, ev.y, ev.width, ev.height);
+      });
     } else {
       this._requestRedraw();
     }
@@ -3517,13 +3582,26 @@ export default class Window extends Drawable {
    * either makes you the window manager or rejects with BadAccess because
    * something else already is. The mask is OR-ed into whatever handlers
    * have already asked for.
+   *
+   * A mask this connection already holds is a request that would change
+   * nothing, so it resolves without one — `eventMask` is what this
+   * connection selected and nothing else adds to it behind the caller's
+   * back. It resolves rather than returning undefined because the promise is
+   * the whole interface: an awaited no-op still has to mean "you have it".
    */
   selectInput(mask) {
-    this.eventMask |= mask;
+    const added = mask & ~this.eventMask;
+    if (added === 0) return Promise.resolve(this);
+    this.eventMask |= added;
     return new Promise((resolve, reject) => {
-      this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, (err) =>
-        err ? reject(err) : resolve(this)
-      );
+      this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, (err) => {
+        if (!err) return resolve(this);
+        // a refused write left the server's mask as it was — give back the
+        // bits, or the next call would find them held and skip a request
+        // that has not happened yet
+        this.eventMask &= ~added;
+        reject(err);
+      });
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.3.0",
+  "version": "8.3.1",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",