ntk 6.3.0 → 6.5.0

package/lib/builtin.js

@@ -0,0 +1,47 @@
+// Reach a Node builtin from ESM across Node versions.
+//
+// `process.getBuiltinModule(id)` is the browser-safe accessor — the string is
+// a function argument, so no bundler treats it as a module specifier — but it
+// only exists on Node >= 20.16. ntk's floor is lower (Node 18.19, for
+// react-x11), and there is no browser-safe, synchronous way to reach a builtin
+// from ESM on an older Node: `getBuiltinModule` is the API that was added to
+// fill exactly that gap. So where it is absent we fall back to `createRequire`.
+//
+// The `node:module` import below is a real specifier and the one place in lib/
+// allowed to statically import a builtin other than node:events — a sanctioned
+// exception in test/packaging.test.js, scoped to this file. A *browser* bundle
+// of the text stack must stub this one specifier, but the fallback that uses it
+// never runs in a browser (guarded on process.versions.node) and ntk ships no
+// browser build. It is not a top-level await, so the CJS/SEA bundle path (see
+// docs/packaging.md) is unaffected.
+import { createRequire } from 'node:module';
+
+let _require;
+
+// One createRequire bound to ntk, made lazily. Builtins ('node:*') resolve
+// regardless of the base URL, so this also serves callers that resolve a
+// package in ntk's own dependency graph (e.g. KaTeX's font directory).
+function req() {
+  return (_require ??= createRequire(import.meta.url));
+}
+
+/**
+ * `process.getBuiltinModule(id)` with a Node-18 fallback.
+ * @param {string} id e.g. 'node:child_process'
+ * @returns the builtin module, or `undefined` outside Node (a browser
+ *   embedding of the text stack — supply a custom FontSource / callback there).
+ */
+export function builtin(id) {
+  const p = globalThis.process;
+  if (!p?.versions?.node) return undefined;
+  if (typeof p.getBuiltinModule === 'function') return p.getBuiltinModule(id);
+  return req()(id);
+}
+
+/**
+ * A `require` for resolving packages in ntk's dependency graph.
+ * @returns {NodeRequire|null} `null` outside Node.
+ */
+export function nodeRequire() {
+  return globalThis.process?.versions?.node ? req() : null;
+}

package/lib/fontconfig.js

@@ -1,8 +1,10 @@
-// node:child_process is fetched lazily (not via static import) so that
-// browser bundles of the package never try to resolve it; in non-node
+// node:child_process is fetched lazily (via builtin(), not a static import) so
+// that browser bundles of the package never try to resolve it; in non-node
 // environments use a custom FontSource instead (see text/fontsource.js).
+import { builtin } from './builtin.js';
+
 function childProcess() {
-  return globalThis.process?.getBuiltinModule?.('node:child_process');
+  return builtin('node:child_process');
 }
 
 function execFileSync(...args) {

package/lib/glx.js

@@ -1,10 +1,115 @@
-// GLX visual/fbconfig discovery.
+// GLX visual/fbconfig discovery, and the diagnosis of a failed setup.
 //
 // A GLX drawable has to use a visual the GL context was created for, so the
 // visual must be known *before* CreateWindow. This module asks the server
 // (GetFBConfigs, falling back to the GLX 1.2 GetVisualConfigs) instead of
 // shelling out to `glxinfo`, so it works headlessly and in CI.
 
+/**
+ * `err.code` on every error this module and the OpenGL context throw, so
+ * callers can branch on the cause instead of matching on message text.
+ *
+ * - `GLX_NO_EXTENSION` — the server does not have the GLX extension.
+ * - `GLX_INDIRECT_DISABLED` — it has GLX, but refuses indirect contexts,
+ *   which is the only kind that works over the wire. The default on Xorg
+ *   >= 1.17 and Xwayland, and by far the most common failure.
+ * - `GLX_NO_CONFIG` — no visual/fbconfig matches the requested attributes.
+ * - `GLX_CONTEXT_FAILED` — anything else that went wrong in setup.
+ */
+export const GLXError = {
+  NO_EXTENSION: 'GLX_NO_EXTENSION',
+  INDIRECT_DISABLED: 'GLX_INDIRECT_DISABLED',
+  NO_CONFIG: 'GLX_NO_CONFIG',
+  CONTEXT_FAILED: 'GLX_CONTEXT_FAILED'
+};
+
+// `message` says what is wrong in one line; `hint` is the multi-line
+// remedy, printed by the default warning and available to anyone rendering
+// their own fallback UI.
+function glxError(code, message, hint, cause) {
+  const err = new Error(message);
+  err.code = code;
+  if (hint) err.hint = hint;
+  if (cause) err.cause = cause;
+  return err;
+}
+
+const displayName = () => process.env.DISPLAY || 'the X server';
+
+const IGLX_HINT = `Indirect GLX is what ntk draws with: GL commands travel over the X
+connection, since there is no client-side GL library involved. Xorg >= 1.17
+and Xwayland ship with it disabled, and answer GLX CreateContext with
+BadValue. The extension is still present and still advertises GLX 1.4 with a
+full set of fbconfigs, which is why this looks like it should have worked.
+
+To get a server that allows it:
+  under Wayland:  Xwayland :5 +iglx &  then DISPLAY=:5
+  under X:        Xephyr :5 +iglx &    then DISPLAY=:5
+  Xorg:           +iglx on the command line, or
+                  Option "AllowIndirectGLX" "on" in xorg.conf
+  XQuartz:        defaults write org.xquartz.X11 enable_iglx -bool true
+
+Note that on current Linux distros the indirect GL *engine* behind those
+contexts is often gone even with +iglx on — contexts are created but nothing
+rasterizes. See docs/context-opengl.md.`;
+
+/** Turn a failed GLX CreateContext into an error that explains itself. */
+export function diagnoseCreateContext(err, cfg) {
+  // BadValue with value 0 from CreateContext (minor opcode 3) is how a
+  // server without +iglx says "no indirect contexts here" — every other
+  // rejection names the value it disliked
+  if (err?.error === 2 && err.badParam === 0) {
+    return glxError(
+      GLXError.INDIRECT_DISABLED,
+      `${displayName()} has GLX but refuses to create indirect GLX contexts, so there is no OpenGL context to draw with`,
+      IGLX_HINT,
+      err
+    );
+  }
+  const visual = cfg?.visual ? ` for visual 0x${cfg.visual.toString(16)}` : '';
+  return glxError(
+    GLXError.CONTEXT_FAILED,
+    `GLX CreateContext${visual} failed: ${err?.message ?? err}`,
+    null,
+    err
+  );
+}
+
+/**
+ * The console form of a failed GL setup: what went wrong, then how to fix
+ * it. Indented so the remedy reads as one block and not as unrelated log
+ * lines, and ending with the way to take over the handling.
+ */
+export function glxErrorReport(err) {
+  const lines = [`ntk: getContext('opengl') failed — ${err?.message ?? err}`];
+  if (err?.hint) lines.push('', ...err.hint.split('\n').map((l) => (l ? `  ${l}` : l)));
+  lines.push('', `  (await gl.ready to handle this yourself; err.code is ${err?.code ?? 'unset'})`);
+  return lines.join('\n');
+}
+
+/**
+ * Create a GLX context and find out whether it worked.
+ *
+ * CreateContext has no reply, so its failure would otherwise surface as an
+ * unattributed X error plus a misleading GLXBadContext from the MakeCurrent
+ * that follows. node-x11 >= 3.8 takes a callback here; older versions
+ * cannot report it at all, and this resolves optimistically rather than
+ * hanging.
+ */
+export function createContext(GLX, ctx, cfg) {
+  if (GLX.CreateContext.length < 6) {
+    GLX.CreateContext(ctx, cfg.visual, cfg.screen ?? 0, 0, 0);
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    GLX.CreateContext(ctx, cfg.visual, cfg.screen ?? 0, 0, 0, (err) => {
+      if (err) reject(diagnoseCreateContext(err, cfg));
+      else resolve();
+      return true; // handled here; keep it away from the app's onXError
+    });
+  });
+}
+
 // defaults applied on top of the caller's spec; `null` means "don't care"
 const DEFAULT_SPEC = {
   DOUBLEBUFFER: true,
@@ -120,8 +225,12 @@ function matchLegacy(configs, spec) {
 export async function chooseGLXConfig(app, spec = {}) {
   const GLX = app.display.GLX;
   if (!GLX) {
-    throw new Error(
-      'GLX: extension not available on this display — indirect GLX is often disabled (X server flag +iglx / AllowIndirectGLX)'
+    throw glxError(
+      GLXError.NO_EXTENSION,
+      `${displayName()} does not have the GLX extension, so it cannot do OpenGL at all`,
+      'A server built without GLX, or started with -extension GLX. This is a\n' +
+        'different problem from indirect GLX being disabled, which is the usual\n' +
+        'one — there the extension is present and CreateContext is what fails.'
     );
   }
 
@@ -135,7 +244,11 @@ export async function chooseGLXConfig(app, spec = {}) {
 
   if (want.visual) {
     const info = visualInfo(screen, want.visual);
-    if (!info) throw new Error(`GLX: visual 0x${want.visual.toString(16)} is not on screen ${screenNum}`);
+    if (!info)
+      throw glxError(
+        GLXError.NO_CONFIG,
+        `GLX: visual 0x${want.visual.toString(16)} is not on screen ${screenNum}`
+      );
     return {
       visual: want.visual,
       depth: info.depth,
@@ -187,8 +300,10 @@ export async function chooseGLXConfig(app, spec = {}) {
   const legacyBest = pick(fromVisuals);
   if (legacyBest) return legacyBest;
 
-  throw new Error(
-    `GLX: no visual on screen ${screenNum} matches ${describe(want)} (server offered ${legacy.length} GLX visuals)`
+  throw glxError(
+    GLXError.NO_CONFIG,
+    `GLX: no visual on screen ${screenNum} matches ${describe(want)} (server offered ${legacy.length} GLX visuals)`,
+    'Relax the spec — DEPTH_SIZE and DOUBLEBUFFER are the usual culprits.'
   );
 }
 

package/lib/image.js

@@ -1,6 +1,7 @@
 import jpeg from 'jpeg-js';
 import { PNG } from 'pngjs';
 
+import { builtin } from './builtin.js';
 import { fromStraightRgba, pixelLayout } from './imagedata.js';
 import Picture from './picture.js';
 
@@ -126,7 +127,7 @@ export function decodeImage(buffer) {
 export async function loadImage(source) {
   if (typeof source === 'string' || source instanceof URL) {
     // lazy builtin lookup: browser bundles must not depend on node:fs
-    const fsp = globalThis.process?.getBuiltinModule?.('node:fs/promises');
+    const fsp = builtin('node:fs/promises');
     if (!fsp) {
       throw new Error('loadImage: file paths need node — pass the encoded bytes instead');
     }

package/lib/index.js

@@ -3,6 +3,7 @@ import x11 from 'x11';
 import App from './app.js';
 import Clipboard from './clipboard.js';
 import { BLANK_CURSOR, CursorCache, cursorNames, cursorShapes, resolveCursorShape } from './cursor.js';
+import { GLXError } from './glx.js';
 import Window from './window.js';
 import { loadLayout } from './yoga.js';
 import { decodeKey, groupForState } from './keyboard.js';
@@ -227,7 +228,9 @@ export {
   premultiply,
   cssLength,
   decodeKey,
-  groupForState
+  groupForState,
+  // the `code` on a failed GL setup: branch on it rather than on the message
+  GLXError
 };
 // The layout engine ntk lays HtmlView out with — downstream layout consumers
 // (e.g. the react-x11 renderer) must import it from here rather than from

package/lib/renderingcontext_2d.js

@@ -325,14 +325,14 @@ class RenderingContext2d {
 
     this._clips = [];
     this._dropMasks();
-    for (const gc of [this._gc, this._fillMaskGC]) {
+    for (const gc of [this._gc, this._fillMaskGC, this._clipMaskGC]) {
       if (!gc) continue;
       safeRelease(this.X, () => {
         this.X.FreeGC(gc);
         this.X.ReleaseID(gc);
       });
     }
-    this._gc = this._fillMaskGC = null;
+    this._gc = this._fillMaskGC = this._clipMaskGC = null;
     this._gcs.length = 0;
 
     this._backgroundPicture = this._glyphSource = null;
@@ -1644,13 +1644,15 @@ class RenderingContext2d {
       drawable: tmpPixmap,
       format: R.a8,
     });
-    R.FillRectangles(
-      R.PictOp.Src,
-      tmpMask.id,
-      [0, 0, 0, 0],
-      [0, 0, bb.w, bb.h],
-    );
-    this._rasterizePolys(tmpMask, entry.polys, entry.rule, -bb.x, -bb.y);
+    if (!this._uploadClipCoverage(tmpPixmap, entry, bb)) {
+      R.FillRectangles(
+        R.PictOp.Src,
+        tmpMask.id,
+        [0, 0, 0, 0],
+        [0, 0, bb.w, bb.h],
+      );
+      this._rasterizePolys(tmpMask, entry.polys, entry.rule, -bb.x, -bb.y);
+    }
     R.Composite(
       op,
       tmpMask.id,
@@ -1669,6 +1671,96 @@ class RenderingContext2d {
     tmpPixmap.destroy();
   }
 
+  /**
+   * The clip-mask twin of `_uploadCoverage`: rasterize one clip entry here
+   * and PutImage the coverage into the bbox temp, instead of asking the
+   * server for trapezoids. Returns false — caller falls back to AddTraps —
+   * with no rasterizer, when the policy routes this shape to the server, or
+   * when the rasterizer declines.
+   *
+   * Without this the routing was only half applied. `_uploadCoverage` covers
+   * fills and strokes, so an app that set `rasterPolicy` to keep every
+   * drawing local still emitted an AddTraps per non-rectangular clip, and on
+   * glamor those were the whole remaining cost: a wall of 48 rounded cards
+   * spent 12 AddTraps a frame on clips alone (react-x11#199), 116ms of
+   * server drain per frame, with no policy able to reach them.
+   *
+   * PutImage writes Src, so it replaces the temp's clear as well.
+   */
+  _uploadClipCoverage(tmpPixmap, entry, bb) {
+    const rasterizer = this.window.app.rasterizer;
+    if (!rasterizer) return false;
+    const flat = [];
+    let edges = 0;
+    for (const p of entry.polys) {
+      if (p.pts.length < 6) continue;
+      flat.push(p.pts);
+      edges += p.pts.length / 2;
+    }
+    if (!flat.length) return false;
+    if (
+      routeRaster(bb.w, bb.h, edges, this.window.app.rasterPolicy) !== "local"
+    ) {
+      return false;
+    }
+
+    const coverage = rasterizer.rasterize({
+      polys: flat,
+      rule: entry.rule,
+      dx: -bb.x,
+      dy: -bb.y,
+      width: bb.w,
+      height: bb.h,
+    });
+    if (!coverage) return false;
+
+    // scanlines padded to 4 bytes, as in _uploadCoverage — and as there, a
+    // width that is already a multiple of 4 goes out as a view over the
+    // rasterizer's own bytes with no copy
+    const stride = (bb.w + 3) & ~3;
+    let data;
+    if (stride === bb.w) {
+      data = Buffer.isBuffer(coverage)
+        ? coverage
+        : Buffer.from(coverage.buffer, coverage.byteOffset, coverage.length);
+    } else {
+      data = Buffer.alloc(stride * bb.h);
+      for (let y = 0; y < bb.h; ++y) {
+        Buffer.from(coverage.buffer, coverage.byteOffset + y * bb.w, bb.w).copy(
+          data,
+          y * stride,
+        );
+      }
+    }
+    this.X.PutImage(
+      2,
+      tmpPixmap.id,
+      this._clipGC(tmpPixmap),
+      bb.w,
+      bb.h,
+      0,
+      0,
+      0,
+      8,
+      data,
+    );
+    return true;
+  }
+
+  /**
+   * GC for uploading coverage into a clip temp. Created against the first
+   * temp and kept: every one of them is depth 8 on the same root, which is
+   * all a GC binds to, and the temps themselves come and go per clip entry.
+   */
+  _clipGC(tmpPixmap) {
+    if (!this._clipMaskGC) {
+      this._clipMaskGC = this.X.AllocID();
+      this._gcs.push(this._clipMaskGC);
+      this.X.CreateGC(this._clipMaskGC, tmpPixmap.id);
+    }
+    return this._clipMaskGC;
+  }
+
   _rebuildClipMask() {
     // The stack changed shape (restore, resize): drop the mask rather than
     // rebuild it eagerly. A stack that went back to rectangles never needs

package/lib/renderingcontext_opengl.js

@@ -1,5 +1,5 @@
 import Drawable from './drawable.js';
-import { chooseGLXConfig } from './glx.js';
+import { GLXError, chooseGLXConfig, createContext, glxErrorReport } from './glx.js';
 
 // Indirect GLX rendering context exposing an OpenGL 1.4-style api.
 // Note: many modern X servers ship with indirect GLX disabled — see README.
@@ -14,9 +14,11 @@ class RenderingContextOpenGL {
     const X = window.X;
     const GLX = window.display.GLX;
     if (!GLX) {
-      throw new Error(
-        "getContext('opengl'): the X server has no GLX extension — indirect GLX is often disabled (+iglx / AllowIndirectGLX)"
+      const err = new Error(
+        `getContext('opengl'): ${process.env.DISPLAY || 'the X server'} does not have the GLX extension, so it cannot do OpenGL at all`
       );
+      err.code = GLXError.NO_EXTENSION;
+      throw err;
     }
 
     this.window = window;
@@ -82,9 +84,21 @@ class RenderingContextOpenGL {
 
       const ctx = X.AllocID();
       this.contextId = ctx;
-      GLX.CreateContext(ctx, cfg.visual, cfg.screen ?? 0, 0, 0);
+      // CreateContext first, and on its own: it is the request a server with
+      // indirect GLX disabled rejects, and going on to MakeCurrent would bury
+      // that under a GLXBadContext about the context that was never created
+      await createContext(GLX, ctx, cfg).catch((err) => {
+        this.contextId = 0; // nothing to destroy
+        throw err;
+      });
       const tag = await new Promise((resolve, reject) => {
-        GLX.MakeCurrent(window.id, ctx, 0, (err, contextTag) => (err ? reject(err) : resolve(contextTag)));
+        GLX.MakeCurrent(window.id, ctx, 0, (err, contextTag) => {
+          if (!err) return resolve(contextTag);
+          const failed = new Error(`GLX MakeCurrent failed: ${err.message}`);
+          failed.code = GLXError.CONTEXT_FAILED;
+          failed.cause = err;
+          reject(failed);
+        });
       });
 
       this.contextTag = tag;
@@ -97,9 +111,7 @@ class RenderingContextOpenGL {
     this.ready.catch((err) => {
       this.error = err;
       queue.length = 0;
-      console.warn(
-        `ntk: getContext('opengl') failed: ${err.message} (await gl.ready to handle this yourself)`
-      );
+      console.warn(glxErrorReport(err));
     });
   }
 

package/lib/text/fontsource.js

@@ -30,10 +30,11 @@
 // fontconfig: ntk ships no fonts, so the app has to hand over the ones it
 // ships, and the spec is the short way to say so.
 //
-// node:fs is fetched through `getBuiltinModule` inside the path branch rather
-// than imported, because this file is the one the browser bundle keeps — its
-// whole purpose is running the text stack without a filesystem. Do not turn
-// that into a static import (test/packaging.test.js fails if you do).
+// node:fs is fetched lazily through builtin() inside the path branch, never a
+// direct static import, because this file is the one the browser bundle keeps
+// — its whole purpose is running the text stack without a filesystem. See
+// builtin.js for how the lazy lookup stays version-tolerant.
+import { builtin } from '../builtin.js';
 import { charsetHas, matchSortedSync, noFontsError, prewarm, supported } from '../fontconfig.js';
 import Font from './font.js';
 
@@ -267,7 +268,7 @@ const ACCEPTED =
   'docs/fonts.md';
 
 function fs() {
-  const mod = globalThis.process?.getBuiltinModule?.('node:fs');
+  const mod = builtin('node:fs');
   if (!mod) {
     throw new Error(
       'ntk: a font path can only be read in node. In a browser, fetch the font ' +

package/lib/widgets/htmlview.js

@@ -1,6 +1,7 @@
 import { selectAll } from 'css-select';
 import { textContent } from 'domutils';
 import { parseDocument } from 'htmlparser2';
+import { builtin } from '../builtin.js';
 import Yoga from '../yoga.js';
 
 import { decodeImage, Image } from '../image.js';
@@ -467,15 +468,14 @@ export default class HtmlView {
     // default policy: local files, only relative to an explicit baseUrl.
     // node builtins are fetched lazily — in environments without them
     // (browser bundles) pass a `loadResource` callback instead.
-    const getBuiltin = globalThis.process?.getBuiltinModule;
-    const fs = getBuiltin?.call(process, 'node:fs');
+    const fs = builtin('node:fs');
     if (!fs || !this.baseUrl) return null;
     let base = this.baseUrl;
     if (typeof base === 'string' && !/^[a-z][a-z0-9+.-]*:/i.test(base)) {
       // filesystem path; point at the directory itself when given one
       let p = base;
       if (!/[/\\]$/.test(p) && fs.existsSync(p) && fs.statSync(p).isDirectory()) p += '/';
-      base = getBuiltin.call(process, 'node:url').pathToFileURL(p);
+      base = builtin('node:url').pathToFileURL(p);
     }
     const url = new URL(src, base);
     if (url.protocol !== 'file:') return null;

package/lib/widgets/tex.js

@@ -21,14 +21,11 @@
 import { parseSvgPath } from '../path.js';
 import { flatten } from '../rasterize.js';
 import { trapezoidize } from '../trapezoid.js';
+import { builtin, nodeRequire } from '../builtin.js';
 import Font from '../text/font.js';
 
-// node builtins are fetched lazily so browser bundles never resolve them;
-// there, inject the assets with configureTex() instead.
-function nodeRequire() {
-  const mod = globalThis.process?.getBuiltinModule?.('node:module');
-  return mod ? mod.createRequire(import.meta.url) : null;
-}
+// node builtins are fetched lazily (nodeRequire/builtin) so browser bundles
+// never resolve them; there, inject the assets with configureTex() instead.
 
 // katex is sizable — load it on first formula, not on package import
 let katex = null;
@@ -82,8 +79,8 @@ function katexFontFiles() {
           'TeX rendering: KaTeX fonts cannot be read here — inject them with configureTex({ fonts })'
         );
       }
-      const { readdirSync } = process.getBuiltinModule('node:fs');
-      const { dirname, join } = process.getBuiltinModule('node:path');
+      const { readdirSync } = builtin('node:fs');
+      const { dirname, join } = builtin('node:path');
       fontDir = join(dirname(require.resolve('katex/package.json')), 'dist', 'fonts');
       fontFiles = new Set(readdirSync(fontDir).filter((f) => f.endsWith('.ttf')));
     }

package/lib/window.js

@@ -1,5 +1,6 @@
 import x11 from 'x11';
 
+import { builtin } from './builtin.js';
 import { safeRelease } from './cleanup.js';
 import Drawable from './drawable.js';
 import { packIcons, unpackIcons } from './imagedata.js';
@@ -1086,29 +1087,35 @@ export default class Window extends Drawable {
   }
 
   /**
-   * Whether the fence for the last frame is still unanswered — the server has
-   * not yet confirmed it consumed everything that frame drew.
+   * Whether a blit this window already owes is still waiting to go out —
+   * because the fence for the last frame is unanswered, or because a present
+   * is deferred behind the minimum inter-blit interval.
    *
    * The one bit of frame-clock state worth publishing, because it is the
    * difference between the two ways a toolkit can answer a discrete input.
    * Drawing the response inside the event handler costs a frame less latency:
    * the blit goes out with the handler's own requests (see the `_present()`
    * at the end of the event dispatch) instead of waiting for the next paced
-   * frame — provided the last blit is at least `frameInterval` old, which is
-   * what a discrete input arriving out of the blue always is. Drawing it while
-   * a frame is in flight costs a frame's *work* for nothing: the present is
-   * deferred until the ack and coalesces with the one already pending, so only
-   * the last paint is ever seen. So `false`
+   * frame. Drawing it when a blit is already queued costs a frame's *work* for
+   * nothing: the paint lands in the same backing store and coalesces into the
+   * present already pending, so only the last one is ever seen. So `false`
    * means "draw it now", `true` means "leave it to the frame clock" — which
    * is how a burst of discrete events (a spun wheel) paints its first notch
    * immediately and folds the rest into one catch-up frame.
    *
-   * Always `false` under `frameSync: false`: no fence is ever sent, so there
-   * is nothing to wait for, and a caller gating on this gets the unpaced
-   * behaviour that option asks for.
+   * Both gates have to be reported, not just the fence. The fence is the one
+   * that bites on a slow connection. The minimum inter-blit interval (#195) is
+   * the one that bites on a fast local server, where the fence for a notch is
+   * answered well before the next notch is even read, and what actually holds
+   * the burst back is the interval. Reporting only the fence there answers
+   * "draw it now" to every notch — the precise work this gate exists to skip.
+   *
+   * `false` whenever nothing gates blits at all: `frameSync: false` sends no
+   * fence and `frameInterval: 0` keeps no interval, so a caller who asked for
+   * both gets the unpaced behaviour those options ask for.
    */
   frameInFlight() {
-    return this._frame.inFlight;
+    return this._frame.inFlight || this._presentPending;
   }
 
   _present() {
@@ -1911,7 +1918,7 @@ export default class Window extends Drawable {
   /** os.hostname(), looked up once, and absent in a browser bundle. */
   static _hostname() {
     if (Window._cachedHostname === undefined) {
-      const os = globalThis.process?.getBuiltinModule?.('node:os');
+      const os = builtin('node:os');
       Window._cachedHostname = os?.hostname?.() ?? null;
     }
     return Window._cachedHostname;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "6.3.0",
+  "version": "6.5.0",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",
@@ -30,7 +30,7 @@
     "lib"
   ],
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=18.19.0"
   },
   "dependencies": {
     "bidi-js": "^1.0.3",
@@ -48,7 +48,7 @@
     "parse-color": "^1.0.0",
     "pngjs": "^7.0.0",
     "postcss": "^8.5.23",
-    "x11": "^3.7.0",
+    "x11": "^3.8.0",
     "yoga-layout": "^3.2.1"
   },
   "scripts": {