ntk 8.12.3 → 8.12.4

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/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.4",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",