@turntrout/subfont 1.4.0 → 1.5.1

package/lib/collectTextsByPage.js

@@ -20,7 +20,7 @@ const {
 } = require('./fontFaceHelpers');
 
 const fontRelevantCssRegex =
-  /font-family|font-weight|font-style|font-stretch|font-display|font-size|@font-face|font-variation|font-feature/i;
+  /font-family|font-weight|font-style|font-stretch|font-display|@font-face|font-variation|font-feature/i;
 
 // font-tracer defaults omit font-size. We need it for opsz axis mapping.
 const PROPS_TO_RETURN = [

package/lib/concurrencyLimit.js

@@ -4,7 +4,9 @@ const os = require('os');
 const WORKER_MEMORY_BYTES = 50 * 1024 * 1024; // 50 MB
 
 function getMaxConcurrency() {
-  return Math.max(1, Math.floor(os.totalmem() / WORKER_MEMORY_BYTES));
+  const byMemory = Math.floor(os.freemem() / WORKER_MEMORY_BYTES);
+  const byCpu = os.cpus().length * 4;
+  return Math.max(1, Math.min(byMemory, byCpu));
 }
 
 module.exports = { WORKER_MEMORY_BYTES, getMaxConcurrency };

package/lib/parseCommandLineOptions.js

@@ -111,7 +111,7 @@ module.exports = function parseCommandLineOptions(argv) {
       },
     })
     .options('concurrency', {
-      describe: `Maximum number of worker threads for parallel font tracing. Defaults to the number of CPU cores (max 8). Upper bound: ${maxConcurrency} (based on available memory)`,
+      describe: `Maximum number of worker threads for parallel font tracing. Defaults to the number of CPU cores (max 8). Upper bound: ${maxConcurrency} (based on free memory and CPU count)`,
       type: 'number',
     })
     .check((argv) => {
@@ -121,7 +121,7 @@ module.exports = function parseCommandLineOptions(argv) {
         }
         if (argv.concurrency > maxConcurrency) {
           throw new Error(
-            `--concurrency must not exceed ${maxConcurrency} (each worker uses ~50 MB; system has ${Math.round(os.totalmem() / (1024 * 1024 * 1024))} GB total)`
+            `--concurrency must not exceed ${maxConcurrency} (each worker uses ~50 MB; ${Math.round(os.freemem() / (1024 * 1024 * 1024))} GB free, ${os.cpus().length} CPUs)`
           );
         }
       }

package/lib/subfont.js

@@ -49,7 +49,7 @@ module.exports = async function subfont(
   const maxConcurrency = getMaxConcurrency();
   if (concurrency !== undefined && concurrency > maxConcurrency) {
     throw new UsageError(
-      `--concurrency must not exceed ${maxConcurrency} (each worker uses ~50 MB; system has ${Math.round(os.totalmem() / (1024 * 1024 * 1024))} GB total)`
+      `--concurrency must not exceed ${maxConcurrency} (each worker uses ~50 MB; ${Math.round(os.freemem() / (1024 * 1024 * 1024))} GB free, ${os.cpus().length} CPUs)`
     );
   }
 

package/lib/subsetFontWithGlyphs.js

@@ -29,7 +29,7 @@ function compileModule() {
 
 const _pool = []; // Array of { exports, busy: boolean }
 let _poolReady;
-const POOL_SIZE = Math.min(os.cpus().length, 8);
+const POOL_SIZE = Math.max(1, Math.min(os.cpus().length, 8));
 
 async function initPool() {
   if (!_poolReady) {
@@ -73,9 +73,15 @@ function releaseInstance(inst) {
 
 // Serialize fontverter.convert calls — the wawoff2 module (used internally by
 // fontverter for WOFF2 compression) has a shared WASM instance whose memory
-// is corrupted by concurrent calls.
+// is corrupted by concurrent calls.  Only woff2 paths need this; woff and
+// truetype conversions use separate synchronous/JS libraries that are safe
+// to call in parallel.
 const convertLimiter = require('p-limit')(1);
 
+function usesWawoff2(buffer) {
+  return buffer.length >= 4 && buffer.toString('ascii', 0, 4) === 'wOF2';
+}
+
 // Re-create on every call — WASM memory.buffer is detached when memory grows,
 // so a cached Uint8Array would silently read/write stale data.
 function getHeapu8(exports) {
@@ -224,7 +230,11 @@ async function subsetFontWithGlyphs(
 ) {
   // Reuse cached sfnt conversion when available (same buffer may have
   // been converted by getFontInfo or collectFeatureGlyphIds already).
-  const ttf = await toSfnt(originalFont);
+  // Serialize through convertLimiter when the source is woff2 — toSfnt
+  // would call wawoff2.decompress which isn't concurrency-safe.
+  const ttf = usesWawoff2(originalFont)
+    ? await convertLimiter(() => toSfnt(originalFont))
+    : await toSfnt(originalFont);
 
   const inst = await acquireInstance();
   const { exports } = inst;
@@ -269,12 +279,19 @@ async function subsetFontWithGlyphs(
     released = true;
     releaseInstance(inst);
 
-    return convertLimiter(() =>
-      fontverter.convert(subsetFont, targetFormat, 'truetype')
-    );
+    // Only serialize through convertLimiter when targeting woff2 —
+    // woff and truetype conversions don't use wawoff2.
+    return targetFormat === 'woff2'
+      ? convertLimiter(() =>
+          fontverter.convert(subsetFont, targetFormat, 'truetype')
+        )
+      : fontverter.convert(subsetFont, targetFormat, 'truetype');
   } finally {
     if (!released) releaseInstance(inst);
   }
 }
 
+// Pre-warm the WASM pool: call early to overlap compilation with other work.
+subsetFontWithGlyphs.warmup = () => initPool();
+
 module.exports = subsetFontWithGlyphs;

package/lib/subsetFonts.js

@@ -28,6 +28,7 @@ const {
 } = require('./fontFaceHelpers');
 const { getVariationAxisUsage } = require('./variationAxes');
 const { getSubsetsForFontUsage } = require('./subsetGeneration');
+const subsetFontWithGlyphs = require('./subsetFontWithGlyphs');
 
 const googleFontsCssUrlRegex = /^(?:https?:)?\/\/fonts\.googleapis\.com\/css/;
 
@@ -385,6 +386,13 @@ async function subsetFonts(
     fontDisplay = undefined;
   }
 
+  // Pre-warm the WASM pool: start compiling harfbuzz WASM while
+  // collectTextsByPage traces fonts. Compilation (~50-200ms) overlaps
+  // with tracing work rather than appearing on the critical path.
+  // Catch silently — the error will surface when subsetFontWithGlyphs
+  // is actually called, where it's properly handled.
+  subsetFontWithGlyphs.warmup().catch(() => {});
+
   const subsetUrl = urltools.ensureTrailingSlash(assetGraph.root + subsetPath);
 
   const timings = {};

package/lib/subsetGeneration.js

@@ -9,6 +9,20 @@ const subsetFontWithGlyphs = require('./subsetFontWithGlyphs');
 // entries (e.g. after adding hinting removal or table stripping).
 const SUBSET_CACHE_VERSION = '2';
 
+// Cache the SHA-256 hash state after feeding SUBSET_CACHE_VERSION + fontBuffer.
+// For a font with 2 target formats this halves the hashing work on large buffers.
+// Uses WeakMap so entries are garbage-collected when the buffer is released.
+const fontBufferHashPrefixes = new WeakMap();
+function getFontBufferHashPrefix(fontBuffer) {
+  if (!fontBufferHashPrefixes.has(fontBuffer)) {
+    const hash = crypto.createHash('sha256');
+    hash.update(SUBSET_CACHE_VERSION);
+    hash.update(fontBuffer);
+    fontBufferHashPrefixes.set(fontBuffer, hash);
+  }
+  return fontBufferHashPrefixes.get(fontBuffer);
+}
+
 function subsetCacheKey(
   fontBuffer,
   text,
@@ -16,9 +30,10 @@ function subsetCacheKey(
   variationAxes,
   featureGlyphIds
 ) {
-  const hash = crypto.createHash('sha256');
-  hash.update(SUBSET_CACHE_VERSION);
-  hash.update(fontBuffer);
+  // Clone the pre-computed prefix (version + font buffer) and append
+  // the remaining fields. hash.copy() is O(1) — just copies the
+  // internal digest state, avoiding re-hashing the entire font buffer.
+  const hash = getFontBufferHashPrefix(fontBuffer).copy();
   hash.update(text);
   hash.update(targetFormat);
   if (variationAxes) hash.update(JSON.stringify(variationAxes));
@@ -163,85 +178,99 @@ async function getSubsetsForFontUsage(
   const subsetPromiseMap = new Map();
   const subsetInfoByFontUrl = new Map();
 
-  for (const [fontUrl, fontUsage] of canonicalFontUsageByUrl) {
-    const fontBuffer = originalFontBuffers.get(fontUrl);
-    if (!fontBuffer) continue;
-    const text = fontUsage.text;
+  // Process fonts concurrently — each font's feature glyph collection
+  // and subset queuing run in parallel, so fonts without feature settings
+  // don't wait behind fonts that need collectFeatureGlyphIds.
+  await Promise.all(
+    [...canonicalFontUsageByUrl].map(async ([fontUrl, fontUsage]) => {
+      const fontBuffer = originalFontBuffers.get(fontUrl);
+      if (!fontBuffer) return;
+      const text = fontUsage.text;
 
-    const bounds = variationAxisBoundsCache.get(fontUrl);
-    const subsetInfo = bounds
-      ? {
-          variationAxes: bounds.variationAxes,
-          fullyInstanced: bounds.fullyInstanced,
-          numAxesPinned: bounds.numAxesPinned,
-          numAxesReduced: bounds.numAxesReduced,
+      const bounds = variationAxisBoundsCache.get(fontUrl);
+      const subsetInfo = bounds
+        ? {
+            variationAxes: bounds.variationAxes,
+            fullyInstanced: bounds.fullyInstanced,
+            numAxesPinned: bounds.numAxesPinned,
+            numAxesReduced: bounds.numAxesReduced,
+          }
+        : {
+            variationAxes: undefined,
+            fullyInstanced: false,
+            numAxesPinned: 0,
+            numAxesReduced: 0,
+          };
+      subsetInfoByFontUrl.set(fontUrl, subsetInfo);
+
+      let featureGlyphIds;
+      if (fontUsage.hasFontFeatureSettings && fontBuffer) {
+        try {
+          featureGlyphIds = await collectFeatureGlyphIds(
+            fontBuffer,
+            text,
+            fontUsage.fontFeatureTags
+          );
+        } catch (err) {
+          // Feature glyph collection failed — continue without feature
+          // glyphs rather than blocking all fonts (Promise.all would
+          // reject entirely if this propagated).
+          err.asset = err.asset || fontAssetsByUrl.get(fontUrl);
+          assetGraph.warn(err);
         }
-      : {
-          variationAxes: undefined,
-          fullyInstanced: false,
-          numAxesPinned: 0,
-          numAxesReduced: 0,
-        };
-    subsetInfoByFontUrl.set(fontUrl, subsetInfo);
+      }
 
-    let featureGlyphIds;
-    if (fontUsage.hasFontFeatureSettings && fontBuffer) {
-      featureGlyphIds = await collectFeatureGlyphIds(
-        fontBuffer,
-        text,
-        fontUsage.fontFeatureTags
-      );
-    }
+      for (const targetFormat of formats) {
+        const promiseId = getSubsetPromiseId(
+          fontUsage,
+          targetFormat,
+          subsetInfo.variationAxes
+        );
 
-    for (const targetFormat of formats) {
-      const promiseId = getSubsetPromiseId(
-        fontUsage,
-        targetFormat,
-        subsetInfo.variationAxes
-      );
+        if (!subsetPromiseMap.has(promiseId)) {
+          const cacheKey = diskCache
+            ? subsetCacheKey(
+                fontBuffer,
+                text,
+                targetFormat,
+                subsetInfo.variationAxes,
+                featureGlyphIds
+              )
+            : null;
+          const cachedResult = diskCache ? await diskCache.get(cacheKey) : null;
 
-      if (!subsetPromiseMap.has(promiseId)) {
-        const cacheKey = diskCache
-          ? subsetCacheKey(
-              fontBuffer,
-              text,
+          if (cachedResult) {
+            subsetPromiseMap.set(promiseId, Promise.resolve(cachedResult));
+          } else {
+            const subsetCall = subsetFontWithGlyphs(fontBuffer, text, {
               targetFormat,
-              subsetInfo.variationAxes,
-              featureGlyphIds
-            )
-          : null;
-        const cachedResult = diskCache ? await diskCache.get(cacheKey) : null;
+              glyphIds: featureGlyphIds,
+              variationAxes: subsetInfo.variationAxes,
+            });
 
-        if (cachedResult) {
-          subsetPromiseMap.set(promiseId, Promise.resolve(cachedResult));
-        } else {
-          const subsetCall = subsetFontWithGlyphs(fontBuffer, text, {
-            targetFormat,
-            glyphIds: featureGlyphIds,
-            variationAxes: subsetInfo.variationAxes,
-          });
-
-          subsetPromiseMap.set(
-            promiseId,
-            subsetCall
-              .then(async (result) => {
-                if (diskCache && result) {
-                  // Fire-and-forget: cache writes are best-effort.
-                  // Errors are handled inside set(); the catch is a
-                  // safety net against unhandled rejections.
-                  diskCache.set(cacheKey, result).catch(() => {});
-                }
-                return result;
-              })
-              .catch((err) => {
-                err.asset = err.asset || fontAssetsByUrl.get(fontUrl);
-                assetGraph.warn(err);
-              })
-          );
+            subsetPromiseMap.set(
+              promiseId,
+              subsetCall
+                .then(async (result) => {
+                  if (diskCache && result) {
+                    // Fire-and-forget: cache writes are best-effort.
+                    // Errors are handled inside set(); the catch is a
+                    // safety net against unhandled rejections.
+                    diskCache.set(cacheKey, result).catch(() => {});
+                  }
+                  return result;
+                })
+                .catch((err) => {
+                  err.asset = err.asset || fontAssetsByUrl.get(fontUrl);
+                  assetGraph.warn(err);
+                  return null;
+                })
+            );
+          }
         }
       }
-    }
-  }
+    })
+  );
 
   // Await all subset promises
   const resolvedSubsets = new Map(

package/lib/wasmQueue.js

@@ -5,7 +5,10 @@
 let queue = Promise.resolve();
 
 function enqueue(fn) {
-  return (queue = queue.then(fn, fn));
+  return (queue = queue.then(
+    () => fn(),
+    () => fn()
+  ));
 }
 
 module.exports = enqueue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turntrout/subfont",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Automatically subset web fonts to only the characters used on your pages. Fork of Munter/subfont with modern defaults.",
   "engines": {
     "node": ">=18.0.0"