@turntrout/subfont 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -33,3 +33,10 @@ On [TurnTrout.com](https://github.com/alexander-turner/TurnTrout.com) (382 pages
 
 - Fixed crash on invalid/corrupt font files during instancing.
 - Fixed incorrect axis range computation for variable fonts.
+- Fixed OOM / >1h runtimes on large sites. `font-size` was added to
+  `font-tracer`'s `propsToReturn` to derive `opsz`, which bucketed every text
+  chunk by size and exploded per-page entry counts 10-50x on sites with many
+  distinct sizes (headings, dropcaps, smallcaps). `opsz` now falls back to
+  pinning at the font default (the pre-regression behaviour); an explicit
+  `font-variation-settings: "opsz" …` still narrows the axis. TurnTrout.com
+  returned from 46+ min / runner-OOM to ~33 min.

package/README.md

@@ -105,6 +105,37 @@ const assetGraph = await subfont(
 
 Returns the [Assetgraph](https://github.com/assetgraph/assetgraph) instance.
 
+### Parameters
+
+`subfont(options, console)` — the second argument is an optional logger (anything
+with `log`, `warn`, and `error` methods — e.g. the global `console`). Pass
+`null` together with `silent: true` to suppress all output.
+
+The `options` object accepts the following keys:
+
+| Option          | Type                | Default  | Description                                                                                                  |
+| --------------- | ------------------- | -------- | ------------------------------------------------------------------------------------------------------------ |
+| `inputFiles`    | `string[]`          | `[]`     | HTML entry points (file paths or URLs). At least one is required unless `root` is given.                     |
+| `root`          | `string`            | deduced  | Path or URL to the web root. Deduced from `inputFiles` if omitted.                                           |
+| `canonicalRoot` | `string`            | —        | URI root where the site will be deployed (used to rewrite absolute URLs).                                    |
+| `output`        | `string`            | —        | Output directory. Mutually exclusive with `inPlace`.                                                         |
+| `inPlace`       | `boolean`           | `false`  | Modify input files in place.                                                                                 |
+| `dryRun`        | `boolean`           | `false`  | Trace and compute subsets but do not write any files.                                                        |
+| `recursive`     | `boolean`           | `false`  | Crawl linked pages starting from `inputFiles`.                                                               |
+| `dynamic`       | `boolean`           | `false`  | Trace JS-rendered content in headless Chrome (via puppeteer).                                                |
+| `fallbacks`     | `boolean`           | `true`   | Keep the full original font for characters outside the subset.                                               |
+| `fontDisplay`   | `string`            | `'swap'` | `font-display` CSS value: `auto`, `block`, `swap`, `fallback`, or `optional`.                                |
+| `text`          | `string`            | —        | Extra characters to include in every subset.                                                                 |
+| `inlineCss`     | `boolean`           | `false`  | Inline the subset `@font-face` CSS into the HTML document.                                                   |
+| `relativeUrls`  | `boolean`           | `false`  | Emit relative URLs instead of root-relative URLs.                                                            |
+| `sourceMaps`    | `boolean`           | `false`  | Preserve CSS source maps (slower).                                                                           |
+| `concurrency`   | `number`            | auto     | Max parallel tracing workers. Capped by available memory (~50 MB per worker).                                |
+| `chromeFlags`   | `string[]`          | `[]`     | Extra Chrome flags forwarded to puppeteer when `dynamic` is set.                                             |
+| `cache`         | `boolean \| string` | `false`  | Cache subset results between runs. Pass a path to customize the cache directory; `true` uses the OS tmp dir. |
+| `strict`        | `boolean`           | `false`  | Resolve with a non-zero exit (via the CLI) if any warnings are emitted.                                      |
+| `silent`        | `boolean`           | `false`  | Suppress all log output to `console`.                                                                        |
+| `debug`         | `boolean`           | `false`  | Emit verbose timing and glyph-detection info.                                                                |
+
 ## License
 
 MIT -- Original work by [Peter Muller (Munter)](https://github.com/Munter/subfont)

package/lib/collectTextsByPage.js

@@ -18,22 +18,15 @@ const {
   uniqueChars,
   uniqueCharsFromArray,
 } = require('./fontFaceHelpers');
+const {
+  createPageProgress,
+  logTracedPage,
+  makePhaseTracker,
+} = require('./progress');
 
 const fontRelevantCssRegex =
   /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 = [
-  'font-family',
-  'font-style',
-  'font-weight',
-  'font-variant',
-  'font-stretch',
-  'font-variation-settings',
-  'animation-timing-function',
-  'font-size',
-];
-
 // The \s before style ensures we don't match data-style or similar.
 const inlineFontStyleRegex =
   /(?:^|\s)style\s*=\s*["'][^"']*\b(?:font-family|font-weight|font-style|font-stretch|font\s*:)/i;
@@ -47,241 +40,11 @@ const fontFaceTraversalTypes = new Set(['HtmlStyle', 'SvgStyle', 'CssImport']);
 // the overhead of worker thread startup exceeds the parallelism benefit).
 const MIN_PAGES_FOR_WORKER_POOL = 4;
 
-const featureSettingsProps = new Set([
-  'font-feature-settings',
-  'font-variant-alternates',
-  'font-variant-caps',
-  'font-variant-east-asian',
-  'font-variant-ligatures',
-  'font-variant-numeric',
-  'font-variant-position',
-]);
-
-// Map font-variant-* CSS values to their corresponding OpenType feature tags.
-const fontVariantToOTTags = {
-  'font-variant-ligatures': {
-    'common-ligatures': ['liga', 'clig'],
-    'no-common-ligatures': ['liga', 'clig'],
-    'discretionary-ligatures': ['dlig'],
-    'no-discretionary-ligatures': ['dlig'],
-    'historical-ligatures': ['hlig'],
-    'no-historical-ligatures': ['hlig'],
-    contextual: ['calt'],
-    'no-contextual': ['calt'],
-  },
-  'font-variant-caps': {
-    'small-caps': ['smcp'],
-    'all-small-caps': ['smcp', 'c2sc'],
-    'petite-caps': ['pcap'],
-    'all-petite-caps': ['pcap', 'c2pc'],
-    unicase: ['unic'],
-    'titling-caps': ['titl'],
-  },
-  'font-variant-numeric': {
-    'lining-nums': ['lnum'],
-    'oldstyle-nums': ['onum'],
-    'proportional-nums': ['pnum'],
-    'tabular-nums': ['tnum'],
-    'diagonal-fractions': ['frac'],
-    'stacked-fractions': ['afrc'],
-    ordinal: ['ordn'],
-    'slashed-zero': ['zero'],
-  },
-  'font-variant-position': {
-    sub: ['subs'],
-    super: ['sups'],
-  },
-  'font-variant-east-asian': {
-    jis78: ['jp78'],
-    jis83: ['jp83'],
-    jis90: ['jp90'],
-    jis04: ['jp04'],
-    simplified: ['smpl'],
-    traditional: ['trad'],
-    'proportional-width': ['pwid'],
-    'full-width': ['fwid'],
-    ruby: ['ruby'],
-  },
-};
-
-// Extract OpenType feature tags referenced by a CSS declaration.
-function extractFeatureTagsFromDecl(prop, value) {
-  const tags = new Set();
-  const propLower = prop.toLowerCase();
-
-  if (propLower === 'font-feature-settings') {
-    // Parse quoted 4-letter tags: "liga" 1, 'dlig', etc.
-    const re = /["']([a-zA-Z0-9]{4})["']/g;
-    let m;
-    while ((m = re.exec(value)) !== null) {
-      tags.add(m[1]);
-    }
-    return tags;
-  }
-
-  if (propLower === 'font-variant-alternates') {
-    const v = value.toLowerCase();
-    if (v.includes('historical-forms')) tags.add('hist');
-    if (/stylistic\s*\(/.test(v)) tags.add('salt');
-    if (/swash\s*\(/.test(v)) tags.add('swsh');
-    if (/ornaments\s*\(/.test(v)) tags.add('ornm');
-    if (/annotation\s*\(/.test(v)) tags.add('nalt');
-    if (/styleset\s*\(/.test(v)) {
-      for (let i = 1; i <= 20; i++) {
-        tags.add(`ss${String(i).padStart(2, '0')}`);
-      }
-    }
-    if (/character-variant\s*\(/.test(v)) {
-      for (let i = 1; i <= 99; i++) {
-        tags.add(`cv${String(i).padStart(2, '0')}`);
-      }
-    }
-    return tags;
-  }
-
-  const mapping = fontVariantToOTTags[propLower];
-  if (mapping) {
-    // Split into tokens for exact keyword matching — substring matching
-    // would falsely trigger e.g. "sub" inside "super".
-    const tokens = new Set(value.toLowerCase().split(/\s+/));
-    for (const [keyword, otTags] of Object.entries(mapping)) {
-      if (tokens.has(keyword)) {
-        for (const t of otTags) tags.add(t);
-      }
-    }
-  }
-  return tags;
-}
-
-// Collect feature tags from all feature-related declarations in a CSS rule.
-function ruleFeatureTags(rule) {
-  const tags = new Set();
-  let hasFeatureDecl = false;
-  for (const node of rule.nodes) {
-    if (
-      node.type === 'decl' &&
-      featureSettingsProps.has(node.prop.toLowerCase())
-    ) {
-      hasFeatureDecl = true;
-      for (const t of extractFeatureTagsFromDecl(node.prop, node.value)) {
-        tags.add(t);
-      }
-    }
-  }
-  return hasFeatureDecl ? tags : null;
-}
-
-function ruleFontFamily(rule) {
-  for (let i = rule.nodes.length - 1; i >= 0; i--) {
-    const node = rule.nodes[i];
-    if (node.type === 'decl' && node.prop.toLowerCase() === 'font-family') {
-      return node.value;
-    }
-  }
-  return null;
-}
-
-// Add all items from `tags` into the Set stored at `key` in `map`,
-// creating the Set if it doesn't exist yet.
-function addTagsToMapEntry(map, key, tags) {
-  let s = map.get(key);
-  if (!s) {
-    s = new Set();
-    map.set(key, s);
-  }
-  for (const t of tags) s.add(t);
-}
-
-// Record the OT tags from a single CSS rule into featureTagsByFamily,
-// keyed by font-family (or '*' when no font-family is specified).
-function recordRuleFeatureTags(rule, featureTagsByFamily) {
-  const tags = ruleFeatureTags(rule);
-  if (!tags) return null;
-
-  const fontFamily = ruleFontFamily(rule);
-  if (!fontFamily) {
-    if (featureTagsByFamily) addTagsToMapEntry(featureTagsByFamily, '*', tags);
-    return true; // signals "all families"
-  }
-
-  const families = cssFontParser.parseFontFamily(fontFamily);
-  if (featureTagsByFamily) {
-    for (const family of families) {
-      addTagsToMapEntry(featureTagsByFamily, family.toLowerCase(), tags);
-    }
-  }
-  return families;
-}
-
-// Determine which font-families use font-feature-settings or font-variant-*.
-// Returns null (none detected), a Set of lowercase family names, or true (all).
-// Also populates featureTagsByFamily with the OT tags per family (lowercase).
-function findFontFamiliesWithFeatureSettings(
-  stylesheetsWithPredicates,
-  featureTagsByFamily
-) {
-  let result = null;
-  for (const { asset } of stylesheetsWithPredicates) {
-    if (!asset || !asset.parseTree) continue;
-    asset.parseTree.walkRules((rule) => {
-      if (result === true && !featureTagsByFamily) return;
-
-      const recorded = recordRuleFeatureTags(rule, featureTagsByFamily);
-      if (!recorded) return;
-
-      if (recorded === true) {
-        result = true;
-      } else if (result !== true) {
-        if (!result) result = new Set();
-        for (const family of recorded) {
-          result.add(family.toLowerCase());
-        }
-      }
-    });
-    if (result === true && !featureTagsByFamily) break;
-  }
-  return result;
-}
-
-// Determine whether a template's font families use feature settings, and
-// collect the corresponding OT feature tags from featureTagsByFamily.
-function resolveFeatureSettings(
-  fontFamilies,
-  fontFamiliesWithFeatureSettings,
-  featureTagsByFamily
-) {
-  let hasFontFeatureSettings = false;
-  if (fontFamiliesWithFeatureSettings === true) {
-    hasFontFeatureSettings = true;
-  } else if (fontFamiliesWithFeatureSettings instanceof Set) {
-    for (const f of fontFamilies) {
-      if (fontFamiliesWithFeatureSettings.has(f.toLowerCase())) {
-        hasFontFeatureSettings = true;
-        break;
-      }
-    }
-  }
-
-  let fontFeatureTags;
-  if (hasFontFeatureSettings && featureTagsByFamily) {
-    const tags = new Set();
-    const globalTags = featureTagsByFamily.get('*');
-    if (globalTags) {
-      for (const t of globalTags) tags.add(t);
-    }
-    for (const f of fontFamilies) {
-      const familyTags = featureTagsByFamily.get(f.toLowerCase());
-      if (familyTags) {
-        for (const t of familyTags) tags.add(t);
-      }
-    }
-    if (tags.size > 0) {
-      fontFeatureTags = [...tags];
-    }
-  }
-
-  return { hasFontFeatureSettings, fontFeatureTags };
-}
+const {
+  extractFeatureTagsFromDecl,
+  findFontFamiliesWithFeatureSettings,
+  resolveFeatureSettings,
+} = require('./fontFeatureHelpers');
 
 const allInitialValues = require('./initialValueByProp');
 const initialValueByProp = {
@@ -398,7 +161,6 @@ function computeSnappedGlobalEntries(declarations, globalTextByProps) {
         textAndProps,
         ...snapped,
         fontVariationSettings: textAndProps.props['font-variation-settings'],
-        fontSize: textAndProps.props['font-size'],
       });
     }
   }
@@ -505,9 +267,6 @@ function getOrComputeGlobalFontUsages(
         .map((e) => e.fontVariationSettings)
         .filter((fvs) => fvs && fvs.toLowerCase() !== 'normal')
     );
-    const fontSizes = new Set(
-      fontEntries.map((e) => e.fontSize).filter((fs) => fs !== undefined)
-    );
     // Use first entry's relations for size computation, or extra's if no entries
     const fontRelations =
       fontEntries.length > 0
@@ -543,7 +302,6 @@ function getOrComputeGlobalFontUsages(
       fontStretches,
       fontWeights,
       fontVariationSettings,
-      fontSizes,
     });
   }
 
@@ -556,71 +314,100 @@ function getOrComputeGlobalFontUsages(
 // cyclomatic complexity of collectTextsByPage.
 async function tracePages(
   pagesNeedingFullTrace,
-  { headlessBrowser, concurrency, console, memoizedGetCssRulesByProperty }
+  {
+    headlessBrowser,
+    concurrency,
+    console,
+    memoizedGetCssRulesByProperty,
+    debug = false,
+  }
 ) {
+  const totalPages = pagesNeedingFullTrace.length;
+  if (totalPages === 0) return;
+
   const useWorkerPool =
-    !headlessBrowser &&
-    pagesNeedingFullTrace.length >= MIN_PAGES_FOR_WORKER_POOL;
+    !headlessBrowser && totalPages >= MIN_PAGES_FOR_WORKER_POOL;
+
+  const progress = createPageProgress({
+    total: totalPages,
+    console,
+    label: 'Tracing fonts',
+  });
 
   if (useWorkerPool) {
     const maxWorkers =
       concurrency > 0 ? concurrency : Math.min(os.cpus().length, 8);
-    const numWorkers = Math.min(maxWorkers, pagesNeedingFullTrace.length);
+    const numWorkers = Math.min(maxWorkers, totalPages);
     const pool = new FontTracerPool(numWorkers);
     await pool.init();
 
     try {
-      const totalPages = pagesNeedingFullTrace.length;
-      const showProgress = totalPages >= 10 && console;
-      let tracedCount = 0;
-      const tracePromises = pagesNeedingFullTrace.map(async (pd) => {
-        try {
-          pd.textByProps = await pool.trace(
-            pd.htmlOrSvgAsset.text || '',
-            pd.stylesheetsWithPredicates
-          );
-        } catch (err) {
-          if (console) {
-            console.warn(
-              `Worker fontTracer failed for ${pd.htmlOrSvgAsset.url}, falling back to main thread: ${err.message}`
+      progress.banner(
+        `  Tracing fonts across ${totalPages} pages using ${numWorkers} worker${numWorkers === 1 ? '' : 's'}...`
+      );
+      await Promise.all(
+        pagesNeedingFullTrace.map(async (pd) => {
+          const pageStart = debug ? Date.now() : 0;
+          try {
+            pd.textByProps = await pool.trace(
+              pd.htmlOrSvgAsset.text || '',
+              pd.stylesheetsWithPredicates
             );
+          } catch (err) {
+            if (console) {
+              console.warn(
+                `Worker fontTracer failed for ${pd.htmlOrSvgAsset.url}, falling back to main thread: ${err.message}`
+              );
+            }
+            pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
+              stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
+              getCssRulesByProperty: memoizedGetCssRulesByProperty,
+              asset: pd.htmlOrSvgAsset,
+            });
           }
-          pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
-            stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
-            getCssRulesByProperty: memoizedGetCssRulesByProperty,
-            asset: pd.htmlOrSvgAsset,
-            propsToReturn: PROPS_TO_RETURN,
-          });
-        }
-        tracedCount++;
-        if (showProgress && tracedCount % 10 === 0) {
-          console.log(`  Tracing fonts: ${tracedCount}/${totalPages} pages...`);
-        }
-      });
-      await Promise.all(tracePromises);
+          const idx = progress.tick();
+          logTracedPage(
+            console,
+            debug,
+            idx,
+            totalPages,
+            pd.htmlOrSvgAsset,
+            pageStart
+          );
+        })
+      );
+      progress.done();
     } finally {
       await pool.destroy();
     }
-  } else if (pagesNeedingFullTrace.length > 0) {
-    const totalPages = pagesNeedingFullTrace.length;
-    const showProgress = totalPages >= 10 && console;
+  } else {
+    progress.banner(
+      `  Tracing fonts across ${totalPages} page${totalPages === 1 ? '' : 's'} (single-threaded${headlessBrowser ? ' + headless browser' : ''})...`
+    );
     for (let pi = 0; pi < totalPages; pi++) {
       const pd = pagesNeedingFullTrace[pi];
+      const pageStart = debug ? Date.now() : 0;
       pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
         stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
         getCssRulesByProperty: memoizedGetCssRulesByProperty,
         asset: pd.htmlOrSvgAsset,
-        propsToReturn: PROPS_TO_RETURN,
       });
       if (headlessBrowser) {
         pd.textByProps.push(
           ...(await headlessBrowser.tracePage(pd.htmlOrSvgAsset))
         );
       }
-      if (showProgress && (pi + 1) % 10 === 0) {
-        console.log(`  Tracing fonts: ${pi + 1}/${totalPages} pages...`);
-      }
+      const idx = progress.tick();
+      logTracedPage(
+        console,
+        debug,
+        idx,
+        totalPages,
+        pd.htmlOrSvgAsset,
+        pageStart
+      );
     }
+    progress.done();
   }
 }
 
@@ -629,11 +416,11 @@ async function tracePages(
 // props and only extract visible text content.
 function processFastPathPages(
   fastPathPages,
-  { memoizedGetCssRulesByProperty, console, debug, subTimings }
+  { memoizedGetCssRulesByProperty, subTimings, trackPhase }
 ) {
   if (fastPathPages.length === 0) return;
 
-  const fastPathStart = Date.now();
+  const fastPathPhase = trackPhase('Fast-path extraction');
 
   const repDataCache = new Map();
   function getRepData(representativePd) {
@@ -682,7 +469,6 @@ function processFastPathPages(
         stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
         getCssRulesByProperty: memoizedGetCssRulesByProperty,
         asset: pd.htmlOrSvgAsset,
-        propsToReturn: PROPS_TO_RETURN,
       });
       continue;
     }
@@ -742,11 +528,9 @@ function processFastPathPages(
       });
     }
   }
-  subTimings['Fast-path extraction'] = Date.now() - fastPathStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] Fast-path text extraction (${fastPathPages.length} pages, ${fastPathFallbacks} fell back to full trace): ${subTimings['Fast-path extraction']}ms`
-    );
+  subTimings['Fast-path extraction'] = fastPathPhase.end(
+    `${fastPathPages.length} pages, ${fastPathFallbacks} fell back to full trace`
+  );
 }
 
 async function collectTextsByPage(
@@ -933,12 +717,11 @@ async function collectTextsByPage(
   const globalTextByProps = [];
   const subTimings = {};
 
-  if (debug && console)
-    console.log('[subfont timing] collectTextsByPage started');
-  const timingStart = Date.now();
+  const trackPhase = makePhaseTracker(console, debug);
+  const overallPhase = trackPhase('collectTextsByPage');
 
   // Pre-compute stylesheet results for all pages
-  const stylesheetPrecomputeStart = Date.now();
+  const stylesheetPrecompute = trackPhase('Stylesheet precompute');
   const pageData = [];
   for (const htmlOrSvgAsset of htmlOrSvgAssets) {
     const {
@@ -967,10 +750,9 @@ async function collectTextsByPage(
     });
   }
 
-  if (debug && console)
-    console.log(
-      `[subfont timing] Stylesheet precompute: ${(subTimings['Stylesheet precompute'] = Date.now() - stylesheetPrecomputeStart)}ms (${pageData.length} pages with fonts)`
-    );
+  subTimings['Stylesheet precompute'] = stylesheetPrecompute.end(
+    `${pageData.length} pages with fonts`
+  );
 
   // Group pages by stylesheet cache key — pages sharing the same CSS
   // configuration produce identical font-tracer props, only text differs.
@@ -1000,34 +782,38 @@ async function collectTextsByPage(
     }
   }
 
-  if (debug && console)
+  // Always surface the per-page work breakdown so users can tell at a
+  // glance how much of the run is actual tracing vs cheap CSS-group
+  // reuse. The threshold matches createPageProgress's minTotal so it
+  // only appears on non-trivial runs.
+  if (console && pageData.length >= 5) {
     console.log(
-      `[subfont timing] CSS groups: ${pagesByStylesheetKey.size} unique, ${pagesNeedingFullTrace.length} to trace, ${fastPathPages.length} fast-path`
+      `  ${pageData.length} pages with fonts: ${pagesNeedingFullTrace.length} to trace, ${fastPathPages.length} via cached CSS group (${pagesByStylesheetKey.size} unique groups)`
     );
+  }
 
   const tracingStart = Date.now();
+  const fullTracing = trackPhase(
+    `Full tracing (${pagesNeedingFullTrace.length} pages)`
+  );
   try {
     await tracePages(pagesNeedingFullTrace, {
       headlessBrowser,
       concurrency,
       console,
       memoizedGetCssRulesByProperty,
+      debug,
     });
 
-    subTimings['Full tracing'] = Date.now() - tracingStart;
-    if (debug && console)
-      console.log(
-        `[subfont timing] Full tracing (${pagesNeedingFullTrace.length} pages): ${subTimings['Full tracing']}ms`
-      );
+    subTimings['Full tracing'] = fullTracing.end();
 
     processFastPathPages(fastPathPages, {
       memoizedGetCssRulesByProperty,
-      console,
-      debug,
       subTimings,
+      trackPhase,
     });
 
-    const assembleStart = Date.now();
+    const assemblePhase = trackPhase('Result assembly');
     for (const pd of pageData) {
       for (const textByPropsEntry of pd.textByProps) {
         textByPropsEntry.htmlOrSvgAsset = pd.htmlOrSvgAsset;
@@ -1044,12 +830,8 @@ async function collectTextsByPage(
         featureTagsByFamily: pd.featureTagsByFamily,
       });
     }
-
-    subTimings['Result assembly'] = Date.now() - assembleStart;
+    subTimings['Result assembly'] = assemblePhase.end();
     if (debug && console) {
-      console.log(
-        `[subfont timing] Result assembly: ${subTimings['Result assembly']}ms`
-      );
       console.log(
         `[subfont timing] Total tracing+extraction+assembly: ${
           Date.now() - tracingStart
@@ -1062,12 +844,12 @@ async function collectTextsByPage(
     }
   }
 
-  const postProcessStart = Date.now();
+  const postProcessPhase = trackPhase('Post-processing total');
 
   // Consolidated cache for per-declarations-key data.
   const declCache = new Map();
 
-  const perPageLoopStart = Date.now();
+  const perPageLoopPhase = trackPhase('Per-page loop');
   let snappingTime = 0;
   let globalUsageTime = 0;
 
@@ -1162,7 +944,6 @@ async function collectTextsByPage(
           fontStretches: template.fontStretches,
           fontWeights: template.fontWeights,
           fontVariationSettings: template.fontVariationSettings,
-          fontSizes: template.fontSizes,
           preload: preloadFontUrls.has(template.fontUrl),
           hasFontFeatureSettings,
           fontFeatureTags,
@@ -1172,20 +953,11 @@ async function collectTextsByPage(
     cloningTime += Date.now() - cloneStart;
   }
 
-  subTimings['Per-page loop'] = Date.now() - perPageLoopStart;
-  subTimings['Post-processing total'] = Date.now() - postProcessStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] Per-page loop: ${subTimings['Per-page loop']}ms (snapping: ${snappingTime}ms, globalUsage: ${globalUsageTime}ms, cloning: ${cloningTime}ms)`
-    );
-  if (debug && console)
-    console.log(
-      `[subfont timing] Post-processing total: ${subTimings['Post-processing total']}ms`
-    );
-  if (debug && console)
-    console.log(
-      `[subfont timing] collectTextsByPage total: ${Date.now() - timingStart}ms`
-    );
+  subTimings['Per-page loop'] = perPageLoopPhase.end(
+    `snapping: ${snappingTime}ms, globalUsage: ${globalUsageTime}ms, cloning: ${cloningTime}ms`
+  );
+  subTimings['Post-processing total'] = postProcessPhase.end();
+  overallPhase.end();
 
   for (const fontFaceDeclarations of fontFaceDeclarationsByHtmlOrSvgAsset.values()) {
     for (const fontFaceDeclaration of fontFaceDeclarations) {

package/lib/concurrencyLimit.js

@@ -4,7 +4,11 @@ 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);
+  // Font tracing is CPU-bound (not I/O), so match the pool size to the
+  // core count directly — no multiplier.
+  const byCpu = os.cpus().length;
+  return Math.max(1, Math.min(byMemory, byCpu));
 }
 
 module.exports = { WORKER_MEMORY_BYTES, getMaxConcurrency };