ntk 8.12.3 → 8.12.5

package/lib/fontconfig.js

@@ -255,6 +255,9 @@ function cacheMatches(fc, out) {
   return list;
 }
 
+// fc -> { promise, base }: one child per pattern however many callers ask.
+// `base` is where a prewarm writes its answer (`spawnToFiles`), null for a
+// child whose answer only reaches the event loop.
 const inflight = new Map();
 
 /**
@@ -270,13 +273,14 @@ const inflight = new Map();
  */
 function runFcMatch(fc) {
   const pending = inflight.get(fc);
-  if (pending) return pending;
+  if (pending) return pending.promise;
   const cp = childProcess();
   if (!cp) return Promise.reject(noFontsError(NOT_NODE));
 
-  const promise = new Promise((resolve, reject) => {
+  const entry = { promise: null, base: null };
+  entry.promise = new Promise((resolve, reject) => {
     cp.execFile('fc-match', [...fcMatchArgs, fc], fcMatchOpts, (err, out, stderr) => {
-      inflight.delete(fc);
+      if (inflight.get(fc) === entry) inflight.delete(fc);
       if (!err) return resolve(out);
       // execFile hands stderr to the callback; execFileSync hangs it on the
       // error, which is where the shared diagnosis reads it from
@@ -284,8 +288,152 @@ function runFcMatch(fc) {
       reject(err);
     });
   });
-  inflight.set(fc, promise);
-  return promise;
+  inflight.set(fc, entry);
+  return entry.promise;
+}
+
+// What a prewarm's child runs: fc-match with its answer in a file, then —
+// once that file is complete — the exit status in another, which is what a
+// synchronous caller waits for (`answerSync`). Nothing but shell builtins
+// runs after fc-match, so a PATH that holds fc-match alone is enough.
+const PREWARM_SCRIPT = 'fc-match "$@" > "$0.out" 2> "$0.err"; echo $? > "$0.done"';
+
+// The directory prewarms write into, made on first use: undefined until
+// then, null where it cannot be (no shell, no writable tmpdir), which leaves
+// prewarms on the event loop the way they always were.
+let prewarmDir;
+let prewarmCount = 0;
+
+function prewarmBase() {
+  const fs = builtin('node:fs');
+  const path = builtin('node:path');
+  if (prewarmDir === undefined) {
+    prewarmDir = null;
+    const p = globalThis.process;
+    const os = builtin('node:os');
+    if (p && p.platform !== 'win32' && fs && os && path && fs.existsSync('/bin/sh')) {
+      try {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ntk-fc-'));
+        p.once('exit', () => {
+          try {
+            fs.rmSync(dir, { recursive: true, force: true });
+          } catch {
+            // a tmpdir cleaned up under us is already clean
+          }
+        });
+        prewarmDir = dir;
+      } catch {
+        // a read-only or missing tmpdir: prewarm the old way
+      }
+    }
+  }
+  return prewarmDir === null ? null : path.join(prewarmDir, String(prewarmCount++));
+}
+
+/** The status and answer a prewarm left, once it has left them; null while
+ *  it is still running. */
+function readPrewarm(base) {
+  const fs = builtin('node:fs');
+  let done;
+  try {
+    done = fs.readFileSync(`${base}.done`, 'utf8');
+  } catch {
+    return null;
+  }
+  // `echo` writes the status and the newline in one go, but a read can land
+  // between the file appearing and its bytes arriving
+  if (!done.endsWith('\n')) return null;
+  const status = Number(done);
+  let out = '';
+  if (status === 0) {
+    try {
+      out = fs.readFileSync(`${base}.out`, 'utf8');
+    } catch {
+      return { status: -1, out: '' };
+    }
+  }
+  return { status, out };
+}
+
+function removePrewarm(base) {
+  const fs = builtin('node:fs');
+  for (const ext of ['.out', '.err', '.done']) {
+    try {
+      fs.unlinkSync(base + ext);
+    } catch {
+      // never written, or already gone
+    }
+  }
+}
+
+/**
+ * A prewarm's child, answering through files so that the synchronous path
+ * can take its answer without the event loop (`answerSync`) — which the
+ * first text layout is holding, from inside a render, for as long as the
+ * first frame takes. A prewarm answered through `execFile` alone lands after
+ * that, so the layout it was started for spawned fc-match a second time and
+ * waited for that one instead.
+ *
+ * Null where files cannot be used; the caller prewarms the old way.
+ */
+function spawnToFiles(fc) {
+  const cp = childProcess();
+  const base = cp ? prewarmBase() : null;
+  if (base === null) return null;
+  let child;
+  try {
+    child = cp.spawn('/bin/sh', ['-c', PREWARM_SCRIPT, base, ...fcMatchArgs, fc], {
+      stdio: 'ignore'
+    });
+  } catch {
+    return null;
+  }
+  const entry = { promise: null, base, answer: undefined };
+  entry.promise = new Promise((resolve, reject) => {
+    const settle = () => {
+      if (inflight.get(fc) === entry) inflight.delete(fc);
+      // answered already, by a synchronous caller that could not wait
+      if (entry.answer === undefined) {
+        const left = readPrewarm(base);
+        removePrewarm(base);
+        entry.answer = left && left.status === 0 ? left.out : null;
+      }
+      if (entry.answer !== null) resolve(entry.answer);
+      else reject(new Error(`fc-match for "${fc}" did not answer`));
+    };
+    child.once('error', settle);
+    child.once('exit', settle);
+  });
+  inflight.set(fc, entry);
+  return entry;
+}
+
+// the synchronous path's nap while a prewarm finishes
+const nap = new Int32Array(new SharedArrayBuffer(4));
+
+// How long the synchronous path waits on a prewarm before asking fc-match
+// itself. fc-match answers in tens of milliseconds, and a prewarm that is
+// running has a head start on any spawn that could replace it.
+const PREWARM_WAIT_MS = 3000;
+
+/**
+ * An in-flight prewarm's answer, waited for synchronously: its stdout, or
+ * null if it failed or took too long — the caller then spawns fc-match
+ * itself, which is also what reports why.
+ */
+function answerSync(fc, entry) {
+  const deadline = performance.now() + PREWARM_WAIT_MS;
+  let left = readPrewarm(entry.base);
+  while (left === null && performance.now() < deadline) {
+    Atomics.wait(nap, 0, 0, 1);
+    left = readPrewarm(entry.base);
+  }
+  if (inflight.get(fc) === entry) inflight.delete(fc);
+  if (entry.answer === undefined) {
+    entry.answer = left && left.status === 0 ? left.out : null;
+    if (left !== null) removePrewarm(entry.base);
+  }
+  return entry.answer;
 }
 
 /**
@@ -294,8 +442,10 @@ function runFcMatch(fc) {
  * 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).
+ * spawn, while the X connection is still being set up, moves that cost off
+ * the critical path (issue #182). The child answers through files as well as
+ * through the event loop, so a layout that asks for the pattern before the
+ * loop has run takes the prewarm's answer rather than spawning its own.
  *
  * 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
@@ -304,9 +454,6 @@ function runFcMatch(fc) {
  * `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.
- *
  * `matchSorted` is the reporting variant: same spawn, same cache, but it
  * awaits an answer and so has somewhere to put a failure.
  *
@@ -316,7 +463,8 @@ function runFcMatch(fc) {
 export function prewarm(pattern = {}) {
   const fc = patternFor(pattern);
   if (sortedCache.has(fc) || unavailable) return Promise.resolve();
-  return runFcMatch(fc).then(
+  const pending = inflight.get(fc)?.promise ?? spawnToFiles(fc)?.promise ?? runFcMatch(fc);
+  return pending.then(
     (out) => {
       if (!sortedCache.has(fc)) {
         const list = parseMatches(out);
@@ -327,6 +475,31 @@ export function prewarm(pattern = {}) {
   );
 }
 
+// the faces a family is asked for in: regular, bold, and both in italic
+const FACES = [
+  [400, 'normal'],
+  [700, 'normal'],
+  [400, 'italic'],
+  [700, 'italic']
+];
+const facesWarmed = new Set();
+
+/**
+ * Prewarm a family in the four faces text is set in — once per family.
+ *
+ * A document asks for its family's faces one at a time, as layout reaches
+ * the first bold word, the first emphasis, and each ask that misses is a
+ * synchronous fc-match on the way to the first frame: a Markdown document
+ * waited on five of them, 600 ms on XQuartz. Started together they run side
+ * by side, and each later ask finds its answer there.
+ */
+export function prewarmFaces(pattern = {}) {
+  const family = pattern.family || 'sans-serif';
+  if (facesWarmed.has(family) || unavailable) return;
+  facesWarmed.add(family);
+  for (const [weight, style] of FACES) prewarm({ family, weight, style });
+}
+
 /**
  * The same match list as `matchSortedSync`, without blocking for it.
  *
@@ -352,10 +525,18 @@ export async function matchSorted(pattern = {}) {
   if (unavailable) throw noFontsError(unavailable);
 
   let out;
-  try {
-    out = await runFcMatch(fc);
-  } catch (err) {
-    throw fcMatchError(err);
+  const pending = inflight.get(fc);
+  if (pending?.base) {
+    // a prewarm running for the pattern: its answer, or — if it has none —
+    // a spawn of our own, which is what reports why
+    out = await pending.promise.catch(() => undefined);
+  }
+  if (out === undefined) {
+    try {
+      out = await runFcMatch(fc);
+    } catch (err) {
+      throw fcMatchError(err);
+    }
   }
   // A sync call may have answered this pattern while the child ran. Its list
   // is the cached one, and candidates memoize their parsed charset, so hand
@@ -385,6 +566,14 @@ export function matchSortedSync(pattern) {
   if (cached) return cached;
   if (unavailable) throw noFontsError(unavailable);
 
+  // The family's other faces are the next asks (`prewarmFaces`): started
+  // now, they run beside this one instead of after it.
+  prewarmFaces(pattern);
+  const pending = inflight.get(fc);
+  if (pending?.base) {
+    const out = answerSync(fc, pending);
+    if (out !== null) return sortedCache.get(fc) ?? cacheMatches(fc, out);
+  }
   let out;
   try {
     out = execFileSync('fc-match', [...fcMatchArgs, fc], fcMatchOpts);

package/lib/text/fontmanager.js

@@ -63,6 +63,60 @@ function shapingKeyOf(style) {
   return `${feats}|${language ?? ''}|${letterSpacing || 0}`;
 }
 
+/**
+ * How many shaped words a generation of the memo holds. Two are kept, so a
+ * working set up to twice this survives a relayout; what was asked for in
+ * neither generation is dropped when the current one fills.
+ */
+const SHAPE_GENERATION = 4000;
+
+// The part of a shaping key a style decides, per style object. Built once a
+// span rather than once a word: TextLayout asks for every word of a span with
+// the same object, and the 2D context builds one object per `font` it is
+// given. Neither changes an object after handing it over, so the only field
+// checked again is the resolved face, the one a caller sets after building
+// the rest.
+const shapePrefixes = new WeakMap();
+
+/** The key a style's words are memoized under, with the embedding levels
+ *  they were shaped at: one string per style and level, kept, so a lookup
+ *  hashes nothing it has not hashed before. */
+function shapeGroupOf(style, levelsKey) {
+  const font = style.font;
+  let known = shapePrefixes.get(style);
+  if (known === undefined || known.font !== font) {
+    known = { font, prefix: shapePrefixOf(style), levels: new Map() };
+    shapePrefixes.set(style, known);
+  }
+  // a fragment's levels are one number in the common case, a list only
+  // for mixed-direction text; a list is not worth keeping
+  if (levelsKey.length > 2) return `${known.prefix}|${levelsKey}`;
+  let group = known.levels.get(levelsKey);
+  if (group === undefined) {
+    group = `${known.prefix}|${levelsKey}`;
+    known.levels.set(levelsKey, group);
+  }
+  return group;
+}
+
+function shapePrefixOf(style) {
+  const font = style.font;
+  // A resolved `font` already carries its coordinates in its key, so the
+  // variations and optical-size fragments only earn their keep on the
+  // family path — where two points of one axis would otherwise share a
+  // shaped run, and the second would be drawn with the first's advances.
+  // Features, language and spacing change the glyphs a word shapes to, so
+  // they are part of the key on both paths: without them a word shaped once
+  // plain answered every later request for it with the plain glyphs, and a
+  // `tnum` asked for after that point was silently ignored.
+  const shaping = shapingKeyOf(style);
+  return font
+    ? `${font.key}|${style.size}|${style.weight}|${style.style}|${shaping}`
+    : `${style.family}|${style.size}|${style.weight}|${style.style}|${variationsKeyOf(
+        style.variations
+      )}|${opticalKeyOf(style)}|${shaping}`;
+}
+
 /** Cache-key fragment for the optical size, `''` when the axis is left alone. */
 function opticalKeyOf(style) {
   return opticalSizeFor(style) ?? '';
@@ -136,7 +190,11 @@ export default class FontManager {
     this._matches = new Map(); // family|weight|style -> Font
     this._fallbacks = new Map(); // family|weight|style -> Map(codepoint -> Font|null)
     this._registered = []; // { font, family (lowercase), weight, italic }
-    this._shapeCache = new Map(); // word-level shaping memo (bounded, LRU)
+    // word-level shaping memo, in two generations (`_shapeCached`): each a
+    // map from a style's key to the words shaped in it
+    this._shapeCache = new Map();
+    this._shapeCacheBefore = new Map();
+    this._shapeCount = 0;
   }
 
   /** the FontSource in effect (explicit, else the process-wide default) */
@@ -355,53 +413,45 @@ export default class FontManager {
   }
 
   /**
-   * Memoized shaping used by TextLayout and the canvas text path (bounded
-   * LRU). `levelsKey` is a compact embedding-levels encoding: a single
-   * number when uniform for the whole fragment (the common case), else
-   * comma-separated per-char levels.
+   * Memoized shaping used by TextLayout and the canvas text path, bounded at
+   * two generations of `SHAPE_GENERATION` words. `levelsKey` is a compact
+   * embedding-levels encoding: a single number when uniform for the whole
+   * fragment (the common case), else comma-separated per-char levels.
    */
   _shapeCached(text, style, levelsKey = '0') {
-    const font = style.font;
-    // A resolved `font` already carries its coordinates in its key, so the
-    // variations and optical-size fragments only earn their keep on the
-    // family path — where two points of one axis would otherwise share a
-    // shaped run, and the second would be drawn with the first's advances.
-    // Features, language and spacing change the glyphs a word shapes to, so
-    // they are part of the key on both paths: without them a word shaped once
-    // plain answered every later request for it with the plain glyphs, and a
-    // `tnum` asked for after that point was silently ignored.
-    const shaping = shapingKeyOf(style);
-    const key = font
-      ? `${font.key}|${style.size}|${style.weight}|${style.style}|${shaping}|${levelsKey}|${text}`
-      : `${style.family}|${style.size}|${style.weight}|${style.style}|${variationsKeyOf(
-          style.variations
-        )}|${opticalKeyOf(style)}|${shaping}|${levelsKey}|${text}`;
-    let shaped = this._shapeCache.get(key);
-    if (shaped) {
-      // Map iterates in insertion order: re-inserting a hit moves it to the
-      // tail, so the eviction sweep below walks least-recently-used first
-      this._shapeCache.delete(key);
-      this._shapeCache.set(key, shaped);
-      return shaped;
+    // A hit in this generation is the whole cost of a word a paragraph has
+    // shaped before — a relayout at a new width asks for every word again,
+    // a hundred thousand of them in a long document — so it is two lookups
+    // and nothing built: the style's key is the same string every time
+    // (`shapeGroupOf`), and the word is the only thing hashed. What the
+    // generation before holds is carried over when asked for; what neither
+    // was asked for goes when the generation turns.
+    const group = shapeGroupOf(style, levelsKey);
+    let words = this._shapeCache.get(group);
+    let shaped = words?.get(text);
+    if (shaped) return shaped;
+    shaped = this._shapeCacheBefore.get(group)?.get(text);
+    if (!shaped) {
+      let levels;
+      if (levelsKey.includes(',')) {
+        levels = levelsKey.split(',').map(Number);
+      } else {
+        levels = new Uint8Array(text.length).fill(Number(levelsKey));
+      }
+      shaped = shapeText(this, text, style, levels);
     }
-    let levels;
-    if (levelsKey.includes(',')) {
-      levels = levelsKey.split(',').map(Number);
-    } else {
-      levels = new Uint8Array(text.length).fill(Number(levelsKey));
+    if (this._shapeCount >= SHAPE_GENERATION) {
+      this._shapeCacheBefore = this._shapeCache;
+      this._shapeCache = new Map();
+      this._shapeCount = 0;
+      words = undefined;
     }
-    shaped = shapeText(this, text, style, levels);
-    if (this._shapeCache.size > 4000) {
-      // drop the stale half in one sweep rather than one entry per insert —
-      // a live UI's working set sits at the recent end and survives, where
-      // the old wholesale clear() re-shaped everything on screen
-      let drop = this._shapeCache.size >> 1;
-      for (const k of this._shapeCache.keys()) {
-        if (drop-- <= 0) break;
-        this._shapeCache.delete(k);
-      }
+    if (!words) {
+      words = new Map();
+      this._shapeCache.set(group, words);
     }
-    this._shapeCache.set(key, shaped);
+    words.set(text, shaped);
+    this._shapeCount++;
     return shaped;
   }
 

package/lib/text/fontsource.js

@@ -51,7 +51,7 @@ import {
   matchSorted,
   matchSortedSync,
   noFontsError,
-  prewarm,
+  prewarmFaces,
   supported
 } from '../fontconfig.js';
 import Font from './font.js';
@@ -116,13 +116,13 @@ export function parseFamilies(family) {
 export class FontconfigFontSource {
   constructor() {
     // Construction is the moment fontconfig is chosen as the lookup path, so
-    // the fc-match spawn for the pattern every widget default resolves to —
+    // the fc-match spawns for the pattern every widget default resolves to —
     // sans-serif at regular weight, exactly as FontManager.match normalizes
-    // it — starts here, asynchronously, instead of stalling the first text
-    // layout for ~50ms. Fire-and-forget: prewarm never rejects, and a source
-    // constructed where fc-match is missing stays silent until (unless) text
-    // is actually rendered.
-    prewarm({ family: 'sans-serif', weight: 400, style: 'normal' });
+    // it — and for its bold and italic start here, asynchronously, instead of
+    // stalling the first text layout for ~50ms each. Fire-and-forget:
+    // prewarm never rejects, and a source constructed where fc-match is
+    // missing stays silent until (unless) text is actually rendered.
+    prewarmFaces({ family: 'sans-serif' });
   }
 
   matchSorted(pattern) {

package/package.json

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