ntk 6.0.0 → 6.0.1

package/lib/app.js

@@ -1,6 +1,7 @@
 import Clipboard from './clipboard.js';
 import { CursorCache } from './cursor.js';
 import { chooseGLXConfig } from './glx.js';
+import Picture from './picture.js';
 import Pixmap from './pixmap.js';
 import { DEFAULT_RASTER_POLICY, defaultRasterizer } from './rasterize.js';
 import FontManager from './text/fontmanager.js';
@@ -42,6 +43,7 @@ export default class App {
     this._fonts = null;
     this._clipboard = null;
     this._cursors = null;
+    this._solidPictures = new Map();
     this._rasterizer = undefined;
     // node-x11 emits X errors it cannot route to a request callback as
     // 'error' on the client — from inside its packet parser. With no
@@ -167,12 +169,56 @@ export default class App {
     return new Pixmap(this, args);
   }
 
+  /**
+   * A repeating source Picture of one colour, for compositing. Components
+   * are 0..1 floats, premultiplied by alpha.
+   *
+   * Cached per connection, not per context: colours a context uses are the
+   * app's palette, and `Surface.render` builds a context per call — a
+   * per-context cache made every render recreate its fill colours
+   * server-side. Nothing evicts; a solid is a few dozen bytes on the server
+   * and an app cycles through few colours. Freed in `close()`.
+   *
+   * On RENDER >= 0.10 a solid is one CreateSolidFill request; an older
+   * server (or a hand-built App that skipped the version handshake in
+   * `createClient`) gets a 1x1 repeat pixmap, which composites identically.
+   */
+  solidPicture(r, g, b, a) {
+    const key = `${r}|${g}|${b}|${a}`;
+    let p = this._solidPictures.get(key);
+    if (p) return p;
+
+    const Render = this.display.Render;
+    const [major, minor] = Render.version || [0, 0];
+    if (major > 0 || minor >= 10) {
+      const pid = this.X.AllocID();
+      Render.CreateSolidFill(pid, r, g, b, a);
+      p = new Picture(this, { id: pid });
+    } else {
+      const pixmap = this.createPixmap({ depth: 32, width: 1, height: 1 });
+      const pid = this.X.AllocID();
+      Render.CreatePicture(pid, pixmap.id, Render.rgba32, { repeat: 1 });
+      Render.FillRectangles(Render.PictOp.Src, pid, [r, g, b, a], [0, 0, 1, 1]);
+      p = new Picture(this, { id: pid });
+      p._sourcePixmap = pixmap; // keep the 1x1 pixmap alive alongside the picture
+    }
+    this._solidPictures.set(key, p);
+    return p;
+  }
+
   // flush pending requests and close the connection
   close() {
     if (this._cursors) {
       this._cursors.dispose();
       this._cursors = null;
     }
+    // shared by every context that ever asked (see solidPicture), so their
+    // lifetime is the connection's — context teardown must not free them
+    for (const picture of this._solidPictures.values()) {
+      picture.destroy();
+      picture._sourcePixmap?.destroy();
+    }
+    this._solidPictures.clear();
     return new Promise((resolve) => this.X.close(resolve));
   }
 

package/lib/fontconfig.js

@@ -1,8 +1,12 @@
 // 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
 // environments use a custom FontSource instead (see text/fontsource.js).
+function childProcess() {
+  return globalThis.process?.getBuiltinModule?.('node:child_process');
+}
+
 function execFileSync(...args) {
-  const cp = globalThis.process?.getBuiltinModule?.('node:child_process');
+  const cp = childProcess();
   if (!cp) {
     throw noFontsError(
       'fontconfig matching needs node (the fc-match CLI) and this is not a node environment'
@@ -101,6 +105,69 @@ function patternFor({ family, weight, style }) {
   return fc;
 }
 
+// One command shared by the sync and async paths, so a prewarmed cache entry
+// is byte-for-byte what the sync call would have computed.
+const fcMatchArgs = ['-s', '--format', '%{file}\t%{postscriptname}\t%{charset}\n'];
+const fcMatchOpts = { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 };
+
+/** fc-match -s output -> candidates, filtered to formats fontkit can parse */
+function parseMatches(out) {
+  const list = [];
+  for (const line of out.split('\n')) {
+    const [path, postscriptName, charset] = line.split('\t');
+    if (path && supported.test(path)) {
+      list.push({ path, postscriptName, charset: charset || '', _ranges: null });
+    }
+  }
+  return list;
+}
+
+const prewarming = new Map();
+
+/**
+ * Seed the match cache for a pattern ahead of time, off the event loop.
+ *
+ * matchSortedSync is deliberately synchronous — it answers from inside text
+ * layout — so the first layout for a pattern pays the fc-match spawn (~50ms)
+ * as a first-paint stall. Starting the same command here with a non-blocking
+ * execFile, while the X connection is still being set up, moves that cost off
+ * the critical path (issue #182).
+ *
+ * Never rejects and never reports: a prewarm is an optimization, and an app
+ * that never renders text must not crash — or even warn — over a missing
+ * fc-match. An app that does render text reaches the sync path, which
+ * diagnoses the failure properly. For the same reason nothing here touches
+ * `unavailable`: the first sync throw keeps its original spawn error as
+ * `cause`.
+ *
+ * A sync call racing this one wins — the child's result is discarded
+ * whenever the pattern is already cached by the time it exits.
+ *
+ * @returns {Promise<void>} resolves once the cache is seeded or the attempt
+ *   abandoned
+ */
+export function prewarm(pattern = {}) {
+  const fc = patternFor(pattern);
+  if (sortedCache.has(fc) || unavailable) return Promise.resolve();
+  const inflight = prewarming.get(fc);
+  if (inflight) return inflight;
+  const cp = childProcess();
+  if (!cp) return Promise.resolve();
+
+  const promise = new Promise((resolve) => {
+    cp.execFile('fc-match', [...fcMatchArgs, fc], fcMatchOpts, (err, out) => {
+      prewarming.delete(fc);
+      if (!err && !sortedCache.has(fc)) {
+        const list = parseMatches(out);
+        if (list.length > 0) sortedCache.set(fc, list);
+      }
+      resolve();
+    });
+  });
+  prewarming.set(fc, promise);
+  return promise;
+}
+
 /**
  * Full fontconfig match list for a pattern, best match first — this is the
  * system's font fallback chain. Each candidate carries the unicode coverage
@@ -119,11 +186,7 @@ export function matchSortedSync(pattern) {
 
   let out;
   try {
-    out = execFileSync(
-      'fc-match',
-      ['-s', '--format', '%{file}\t%{postscriptname}\t%{charset}\n', fc],
-      { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }
-    );
+    out = execFileSync('fc-match', [...fcMatchArgs, fc], fcMatchOpts);
   } catch (err) {
     if (err.code === 'ERR_NTK_NO_FONTS') throw err; // no child_process at all
     if (isSpawnFailure(err)) {
@@ -140,13 +203,7 @@ export function matchSortedSync(pattern) {
     throw err;
   }
 
-  list = [];
-  for (const line of out.split('\n')) {
-    const [path, postscriptName, charset] = line.split('\t');
-    if (path && supported.test(path)) {
-      list.push({ path, postscriptName, charset: charset || '', _ranges: null });
-    }
-  }
+  list = parseMatches(out);
   if (list.length === 0) {
     throw noFontsError(
       `fontconfig matched no font ntk can parse for "${fc}" (needs ` +

package/lib/index.js

@@ -106,7 +106,16 @@ export function createClient(options, callback) {
     // synchronously, which keeps the legacy callback form working. The
     // caller's options object is copied, never mutated.
     const appOptions = options ? { ...options } : {};
-    if (appOptions.fontSource != null) appOptions.fontSource = createFontSource(appOptions.fontSource);
+    if (appOptions.fontSource != null) {
+      appOptions.fontSource = createFontSource(appOptions.fontSource);
+    } else {
+      // An app without a fontSource of its own resolves the process default
+      // lazily, at first text layout — too late for the fontconfig source's
+      // async fc-match prewarm to hide the ~50ms spawn (issue #182). Touch
+      // the default now, while the connection handshake runs; only touch,
+      // so a later setDefaultFontSource still takes effect.
+      defaultFontSource();
+    }
 
     x11.createClient(x11Options, (error, display) => {
       if (error) return reject(error);
@@ -124,26 +133,35 @@ export function createClient(options, callback) {
           // rendering too bright.
           if (process.env.NTK_STRICT_COLORS) Render.strictColors = true;
           display.GLX = glxError ? null : GLX;
-          const X = display.client;
-          X.keycode2keysyms = {};
-
-          function updateKeyboardMapping(min, max) {
-            if (max <= min) return;
-            X.GetKeyboardMapping(min, max - min, (err, list) => {
-              if (err) return;
-              for (let i = 0; i < list.length; ++i) X.keycode2keysyms[i + min] = list[i].slice();
-            });
-          }
 
-          X.on('event', (ev) => {
-            // MappingNotify
-            if (ev.type === 34) {
-              updateKeyboardMapping(ev.firstKeyCode, ev.firstKeyCode + ev.count);
+          // RENDER requires the client to declare its version before using
+          // requests beyond 0.0, and the reply is what gates them afterwards
+          // — CreateSolidFill needs 0.10 (see App#solidPicture). 0.11 is the
+          // last published protocol revision.
+          Render.QueryVersion(0, 11, (versionError, version) => {
+            Render.version = versionError ? [0, 0] : version;
+
+            const X = display.client;
+            X.keycode2keysyms = {};
+
+            function updateKeyboardMapping(min, max) {
+              if (max <= min) return;
+              X.GetKeyboardMapping(min, max - min, (err, list) => {
+                if (err) return;
+                for (let i = 0; i < list.length; ++i) X.keycode2keysyms[i + min] = list[i].slice();
+              });
             }
-          });
-          updateKeyboardMapping(display.min_keycode, display.max_keycode);
 
-          resolve(new App(display, appOptions));
+            X.on('event', (ev) => {
+              // MappingNotify
+              if (ev.type === 34) {
+                updateKeyboardMapping(ev.firstKeyCode, ev.firstKeyCode + ev.count);
+              }
+            });
+            updateKeyboardMapping(display.min_keycode, display.max_keycode);
+
+            resolve(new App(display, appOptions));
+          });
         });
       });
     });