@turntrout/subfont 1.5.1 → 1.7.0

package/lib/subfont.js

@@ -1,12 +1,14 @@
 const fsPromises = require('fs/promises');
 const os = require('os');
 const pathModule = require('path');
+const sanitizeFilename = require('sanitize-filename');
 const { getMaxConcurrency } = require('./concurrencyLimit');
 const AssetGraph = require('assetgraph');
 const prettyBytes = require('pretty-bytes');
 const urlTools = require('urltools');
 const util = require('util');
 const subsetFonts = require('./subsetFonts');
+const { makePhaseTracker } = require('./progress');
 
 class UsageError extends Error {
   constructor(message) {
@@ -191,21 +193,20 @@ module.exports = async function subfont(
   }
 
   const outerTimings = {};
+  // The tracker writes with console.log (duck-typed). Route it through
+  // the silent-aware log wrapper so --silent suppresses phase markers
+  // the same way it suppresses other subfont output.
+  const trackPhase = makePhaseTracker({ log }, debug);
 
-  let phaseStart = Date.now();
+  const loadAssetsPhase = trackPhase('loadAssets');
   await assetGraph.loadAssets(inputUrls);
-  outerTimings.loadAssets = Date.now() - phaseStart;
-  if (debug) log(`[subfont timing] loadAssets: ${outerTimings.loadAssets}ms`);
+  outerTimings.loadAssets = loadAssetsPhase.end();
 
-  phaseStart = Date.now();
+  const populatePhase = trackPhase('populate (initial)');
   await assetGraph.populate({
     followRelations: followRelationsQuery,
   });
-  outerTimings['populate (initial)'] = Date.now() - phaseStart;
-  if (debug)
-    log(
-      `[subfont timing] populate (initial): ${outerTimings['populate (initial)']}ms`
-    );
+  outerTimings['populate (initial)'] = populatePhase.end();
 
   const entrypointAssets = assetGraph.findAssets({ isInitial: true });
   const redirectOrigins = new Set();
@@ -269,7 +270,7 @@ module.exports = async function subfont(
     );
   }
 
-  phaseStart = Date.now();
+  const subsetPhase = trackPhase('subsetFonts total');
   const { fontInfo, timings: subsetTimings } = await subsetFonts(assetGraph, {
     inlineCss,
     fontDisplay,
@@ -285,11 +286,9 @@ module.exports = async function subfont(
     chromeArgs: chromeFlags,
     cacheDir,
   });
+  const subsetFontsTotal = subsetPhase.end();
 
-  const subsetFontsTotal = Date.now() - phaseStart;
-  if (debug) log(`[subfont timing] subsetFonts total: ${subsetFontsTotal}ms`);
-
-  phaseStart = Date.now();
+  const postProcessingPhase = trackPhase('post-subsetFonts processing');
   let sumSizesAfter = 0;
   for (const asset of assetGraph.findAssets(sizeableAssetQuery)) {
     sumSizesAfter += asset.rawSrc.length;
@@ -313,11 +312,12 @@ module.exports = async function subfont(
       assetGraph.info(
         new Error(`Pulling down modified stylesheet ${asset.url}`)
       );
-      asset.url = `${assetGraph.root}subfont/${
-        asset.baseName || 'index'
-      }-${asset.md5Hex.slice(0, 10)}${
-        asset.extension || asset.defaultExtension
-      }`;
+      const safeName =
+        sanitizeFilename(asset.baseName || '', { replacement: '_' }) || 'index';
+      asset.url = `${assetGraph.root}subfont/${safeName}-${asset.md5Hex.slice(
+        0,
+        10
+      )}${asset.extension || asset.defaultExtension}`;
     }
   }
 
@@ -343,11 +343,7 @@ module.exports = async function subfont(
     );
   }
 
-  outerTimings['post-subsetFonts processing'] = Date.now() - phaseStart;
-  if (debug)
-    log(
-      `[subfont timing] post-subsetFonts processing: ${outerTimings['post-subsetFonts processing']}ms`
-    );
+  outerTimings['post-subsetFonts processing'] = postProcessingPhase.end();
 
   if (strict && sawWarning) {
     // In non-silent mode, assetgraph's logEvents normally exits earlier via
@@ -358,7 +354,7 @@ module.exports = async function subfont(
     );
   }
 
-  phaseStart = Date.now();
+  const writePhase = trackPhase('writeAssetsToDisc');
   if (!dryRun) {
     await assetGraph.writeAssetsToDisc(
       {
@@ -370,31 +366,67 @@ module.exports = async function subfont(
       assetGraph.root
     );
   }
+  outerTimings.writeAssetsToDisc = writePhase.end();
 
-  outerTimings.writeAssetsToDisc = Date.now() - phaseStart;
-  if (debug)
+  const reportingPhase = trackPhase('output reporting');
+  if (debug) {
+    // One entry per unique (fontUrl, props) variant. A variable-font URL can
+    // back multiple variants, so fontUrl alone is too coarse. Codepoint unions
+    // and subset sizes are per-font, so the remaining per-page variation
+    // worth surfacing is just which pages reference the variant.
+    const SAMPLE_PAGES = 5;
+    const byVariant = new Map();
+    for (const { assetFileName, fontUsages } of fontInfo) {
+      for (const fu of fontUsages) {
+        const p = fu.props || {};
+        const key = [
+          fu.fontUrl || '[inline]',
+          p['font-family'],
+          p['font-weight'],
+          p['font-style'],
+          p['font-stretch'],
+        ].join('\0');
+        let entry = byVariant.get(key);
+        if (!entry) {
+          entry = {
+            fontUrl: fu.fontUrl,
+            props: fu.props,
+            preload: fu.preload,
+            fullyInstanced: fu.fullyInstanced,
+            numAxesPinned: fu.numAxesPinned,
+            numAxesReduced: fu.numAxesReduced,
+            smallestOriginalFormat: fu.smallestOriginalFormat,
+            smallestSubsetFormat: fu.smallestSubsetFormat,
+            smallestOriginalSize: fu.smallestOriginalSize,
+            smallestSubsetSize: fu.smallestSubsetSize,
+            codepoints: fu.codepoints
+              ? {
+                  original: fu.codepoints.original.length,
+                  used: fu.codepoints.used.length,
+                  unused: fu.codepoints.unused.length,
+                }
+              : undefined,
+            pageCount: 0,
+            samplePages: [],
+          };
+          byVariant.set(key, entry);
+        }
+        entry.pageCount += 1;
+        if (entry.samplePages.length < SAMPLE_PAGES) {
+          entry.samplePages.push(assetFileName);
+        }
+      }
+    }
+    for (const entry of byVariant.values()) {
+      const remaining = entry.pageCount - entry.samplePages.length;
+      if (remaining > 0) {
+        entry.samplePages.push(`...and ${remaining} more`);
+      }
+    }
     log(
-      `[subfont timing] writeAssetsToDisc: ${outerTimings.writeAssetsToDisc}ms`
+      `Font variants (aggregated across ${fontInfo.length} page${fontInfo.length === 1 ? '' : 's'}):`
     );
-
-  phaseStart = Date.now();
-  if (debug) {
-    const compactFontInfo = fontInfo.map(({ fontUsages, ...rest }) => ({
-      ...rest,
-      fontUsages: fontUsages.map(({ codepoints, texts, ...fu }) => ({
-        ...fu,
-        codepoints: codepoints
-          ? {
-              original: `[${codepoints.original.length} codepoints]`,
-              used: `[${codepoints.used.length} codepoints]`,
-              unused: `[${codepoints.unused.length} codepoints]`,
-              page: `[${codepoints.page.length} codepoints]`,
-            }
-          : undefined,
-        texts: texts ? `[${texts.length} entries]` : undefined,
-      })),
-    }));
-    log(util.inspect(compactFontInfo, false, 99));
+    log(util.inspect([...byVariant.values()], false, 99));
   }
 
   let totalSavings = sumSizesBefore - sumSizesAfter;
@@ -494,11 +526,7 @@ module.exports = async function subfont(
     )}`
   );
   log(`Total savings: ${prettyBytes(totalSavings)}`);
-  outerTimings['output reporting'] = Date.now() - phaseStart;
-  if (debug)
-    log(
-      `[subfont timing] output reporting: ${outerTimings['output reporting']}ms`
-    );
+  outerTimings['output reporting'] = reportingPhase.end();
 
   const st = subsetTimings || {};
   const details = st.collectTextsByPageDetails || {};

package/lib/subsetFontWithGlyphs.js

@@ -2,6 +2,7 @@ const os = require('os');
 const { readFile } = require('fs').promises;
 const fontverter = require('fontverter');
 const { toSfnt } = require('./sfntCache');
+const { convert: convertInWorker } = require('./fontConverter');
 
 // hb_subset_sets_t enum values — https://github.com/harfbuzz/harfbuzz/blob/main/src/hb-subset.h
 const HB_SUBSET_SETS_GLYPH_INDEX = 0;
@@ -51,6 +52,7 @@ async function initPool() {
 
 // Waiters queue: callers waiting for an idle WASM instance.
 const _waiters = [];
+const ACQUIRE_TIMEOUT_MS = 120_000;
 
 async function acquireInstance() {
   await initPool();
@@ -60,7 +62,23 @@ async function acquireInstance() {
     return idle;
   }
   // All instances busy — wait for one to be released.
-  return new Promise((resolve) => _waiters.push(resolve));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const idx = _waiters.indexOf(entry);
+      if (idx !== -1) _waiters.splice(idx, 1);
+      reject(
+        new Error(
+          `Timed out waiting for a WASM subsetting instance after ${ACQUIRE_TIMEOUT_MS}ms`
+        )
+      );
+    }, ACQUIRE_TIMEOUT_MS);
+    timer.unref();
+    const entry = (inst) => {
+      clearTimeout(timer);
+      resolve(inst);
+    };
+    _waiters.push(entry);
+  });
 }
 
 function releaseInstance(inst) {
@@ -71,16 +89,11 @@ 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.  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';
-}
+// woff2 encode/decode uses wawoff2's WASM module, which has a shared
+// instance that corrupts memory under concurrent use.  Instead of
+// serializing to p-limit(1) in the main thread, we route woff2
+// operations through fontConverterPool — each worker thread loads its
+// own wawoff2 instance, enabling safe parallel compression.
 
 // Re-create on every call — WASM memory.buffer is detached when memory grows,
 // so a cached Uint8Array would silently read/write stale data.
@@ -88,9 +101,11 @@ function getHeapu8(exports) {
   return new Uint8Array(exports.memory.buffer);
 }
 
+// >>> 0 keeps the accumulator unsigned; without it, tags whose first byte
+// exceeds 0x7F would overflow into negative i32 territory after << 24.
 function HB_TAG(str) {
   return str.split('').reduce(function (a, ch) {
-    return (a << 8) + ch.charCodeAt(0);
+    return ((a << 8) >>> 0) + ch.charCodeAt(0);
   }, 0);
 }
 
@@ -216,6 +231,14 @@ function extractSubsetFont(exports, subset) {
   // Fresh view AFTER the WASM calls above — memory.buffer may have been
   // detached by a grow during hb_face_reference_blob / hb_blob_get_data.
   const heapu8 = getHeapu8(exports);
+
+  if (offset + subsetByteLength > heapu8.byteLength) {
+    exports.hb_blob_destroy(result);
+    throw new Error(
+      `WASM returned out-of-bounds offset ${offset} + length ${subsetByteLength} (heap size ${heapu8.byteLength})`
+    );
+  }
+
   const subsetFont = Buffer.from(
     heapu8.subarray(offset, offset + subsetByteLength)
   );
@@ -230,11 +253,8 @@ async function subsetFontWithGlyphs(
 ) {
   // Reuse cached sfnt conversion when available (same buffer may have
   // been converted by getFontInfo or collectFeatureGlyphIds already).
-  // 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);
+  // sfntCache routes woff2 decompression through the worker pool.
+  const ttf = await toSfnt(originalFont);
 
   const inst = await acquireInstance();
   const { exports } = inst;
@@ -279,12 +299,11 @@ async function subsetFontWithGlyphs(
     released = true;
     releaseInstance(inst);
 
-    // Only serialize through convertLimiter when targeting woff2 —
-    // woff and truetype conversions don't use wawoff2.
+    // Route woff2 compression to a worker thread (each spawns its own
+    // wawoff2 WASM instance).  Non-woff2 formats use JS-based converters
+    // that are safe to call concurrently in the main thread.
     return targetFormat === 'woff2'
-      ? convertLimiter(() =>
-          fontverter.convert(subsetFont, targetFormat, 'truetype')
-        )
+      ? convertInWorker(subsetFont, targetFormat, 'truetype')
       : fontverter.convert(subsetFont, targetFormat, 'truetype');
   } finally {
     if (!released) releaseInstance(inst);