@turntrout/subfont 1.5.1 → 1.7.0

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,10 @@ 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 {
+  findFontFamiliesWithFeatureSettings,
+  resolveFeatureSettings,
+} = require('./fontFeatureHelpers');
 
 const allInitialValues = require('./initialValueByProp');
 const initialValueByProp = {
@@ -398,16 +160,16 @@ function computeSnappedGlobalEntries(declarations, globalTextByProps) {
         textAndProps,
         ...snapped,
         fontVariationSettings: textAndProps.props['font-variation-settings'],
-        fontSize: textAndProps.props['font-size'],
       });
     }
   }
   return entries;
 }
 
-// Build global font usage templates and per-page indices from
-// snapped entries. Mutates the declCache entry for declKey in place.
-function getOrComputeGlobalFontUsages(
+// Fill in fontUsageTemplates/pageTextIndex/preloadIndex on the cached
+// declarations entry. No-op on repeat calls — results are shared across
+// pages that resolve to the same @font-face set.
+function populateGlobalFontUsages(
   cached,
   accumulatedFontFaceDeclarations,
   text
@@ -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,
     });
   }
 
@@ -552,88 +310,117 @@ function getOrComputeGlobalFontUsages(
   cached.preloadIndex = textAndPropsToFontUrl;
 }
 
-// Extract font tracing (worker pool + sequential) to reduce
-// cyclomatic complexity of collectTextsByPage.
+// Trace fonts across the given pages. Uses a worker pool when the workload
+// justifies the thread-startup overhead; otherwise falls back to sequential
+// in-process tracing (required when a HeadlessBrowser is driving things).
 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();
   }
 }
 
-// Extract fast-path text extraction to reduce collectTextsByPage complexity.
-// Pages sharing the same CSS configuration reuse the representative's
-// props and only extract visible text content.
+// For each page that shares a representative's CSS configuration, copy the
+// representative's font-variant props and overlay this page's visible text.
+// Returns the number of pages that had to fall back to a full trace
+// (because inline style attributes made the fast path unsafe).
 function processFastPathPages(
   fastPathPages,
-  { memoizedGetCssRulesByProperty, console, debug, subTimings }
+  { memoizedGetCssRulesByProperty }
 ) {
-  if (fastPathPages.length === 0) return;
-
-  const fastPathStart = Date.now();
+  if (fastPathPages.length === 0) return 0;
 
   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,238 +528,205 @@ 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`
-    );
+  return fastPathFallbacks;
 }
 
-async function collectTextsByPage(
-  assetGraph,
-  htmlOrSvgAssets,
-  {
-    text,
-    console,
-    dynamic = false,
-    debug = false,
-    concurrency,
-    chromeArgs = [],
-  } = {}
-) {
-  const htmlOrSvgAssetTextsWithProps = [];
-
-  const memoizedGetCssRulesByProperty = memoizeSync(getCssRulesByProperty);
-
-  const fontFaceDeclarationsByHtmlOrSvgAsset = new Map();
-
-  // Cache stylesheet-dependent results for pages with identical CSS
-  // configurations.
-  const stylesheetResultCache = new Map();
+// Pre-build an index of stylesheet-related relations by source asset
+// to avoid repeated assetGraph.findRelations scans (O(allRelations) each).
+const STYLESHEET_REL_TYPES = [
+  'HtmlStyle',
+  'SvgStyle',
+  'CssImport',
+  'HtmlConditionalComment',
+  'HtmlNoscript',
+];
 
-  // Pre-build an index of stylesheet-related relations by source asset
-  // to avoid repeated assetGraph.findRelations scans (O(allRelations) each).
-  const stylesheetRelTypes = [
-    'HtmlStyle',
-    'SvgStyle',
-    'CssImport',
-    'HtmlConditionalComment',
-    'HtmlNoscript',
-  ];
-  const stylesheetRelsByFromAsset = new Map();
+function indexStylesheetRelations(assetGraph) {
+  const byFromAsset = new Map();
   for (const relation of assetGraph.findRelations({
-    type: {
-      $in: stylesheetRelTypes,
-    },
+    type: { $in: STYLESHEET_REL_TYPES },
   })) {
-    let arr = stylesheetRelsByFromAsset.get(relation.from);
+    let arr = byFromAsset.get(relation.from);
     if (!arr) {
       arr = [];
-      stylesheetRelsByFromAsset.set(relation.from, arr);
+      byFromAsset.set(relation.from, arr);
     }
     arr.push(relation);
   }
+  return byFromAsset;
+}
 
-  // Build a cache key by traversing stylesheet relations, capturing
-  // both asset identity and relation context (media, conditionalComment,
-  // noscript) that affect gatherStylesheetsWithPredicates output.
-  function buildStylesheetKey(htmlOrSvgAsset, skipNonFontInlineCss) {
-    const keyParts = [];
-    const visited = new Set();
-    (function traverse(asset, isNoscript) {
-      if (visited.has(asset)) return;
-      if (!asset.isLoaded) return;
-      visited.add(asset);
-      for (const relation of stylesheetRelsByFromAsset.get(asset) || []) {
-        if (relation.type === 'HtmlNoscript') {
-          traverse(relation.to, true);
-        } else if (relation.type === 'HtmlConditionalComment') {
-          keyParts.push(`cc:${relation.condition}`);
-          traverse(relation.to, isNoscript);
-        } else {
-          const target = relation.to;
-          if (
-            skipNonFontInlineCss &&
-            target.isInline &&
-            target.type === 'Css' &&
-            !fontRelevantCssRegex.test(target.text || '')
-          ) {
-            continue;
-          }
-          const media = relation.media || '';
-          keyParts.push(`${target.id}:${media}:${isNoscript ? 'ns' : ''}`);
-          traverse(target, isNoscript);
+// Build a cache key by traversing stylesheet relations, capturing
+// both asset identity and relation context (media, conditionalComment,
+// noscript) that affect gatherStylesheetsWithPredicates output.
+function buildStylesheetKey(
+  htmlOrSvgAsset,
+  skipNonFontInlineCss,
+  stylesheetRelsByFromAsset
+) {
+  const keyParts = [];
+  const visited = new Set();
+  (function traverse(asset, isNoscript) {
+    if (visited.has(asset)) return;
+    if (!asset.isLoaded) return;
+    visited.add(asset);
+    for (const relation of stylesheetRelsByFromAsset.get(asset) || []) {
+      if (relation.type === 'HtmlNoscript') {
+        traverse(relation.to, true);
+      } else if (relation.type === 'HtmlConditionalComment') {
+        keyParts.push(`cc:${relation.condition}`);
+        traverse(relation.to, isNoscript);
+      } else {
+        const target = relation.to;
+        if (
+          skipNonFontInlineCss &&
+          target.isInline &&
+          target.type === 'Css' &&
+          !fontRelevantCssRegex.test(target.text || '')
+        ) {
+          continue;
         }
+        const media = relation.media || '';
+        keyParts.push(`${target.id}:${media}:${isNoscript ? 'ns' : ''}`);
+        traverse(target, isNoscript);
       }
-    })(htmlOrSvgAsset, false);
-    return keyParts.join('\x1d');
-  }
-
-  function getOrComputeStylesheetResults(htmlOrSvgAsset) {
-    const key = buildStylesheetKey(htmlOrSvgAsset);
-    if (stylesheetResultCache.has(key)) {
-      return stylesheetResultCache.get(key);
     }
+  })(htmlOrSvgAsset, false);
+  return keyParts.join('\x1d');
+}
 
-    const stylesheetsWithPredicates = gatherStylesheetsWithPredicates(
-      htmlOrSvgAsset.assetGraph,
-      htmlOrSvgAsset,
-      stylesheetRelsByFromAsset
-    );
+// Walk the stylesheet graph rooted at htmlOrSvgAsset and collect every
+// @font-face declaration into a flat list, preserving the CSS relation node
+// so callers can correlate declarations back to their source rules.
+function collectFontFaceDeclarations(
+  htmlOrSvgAsset,
+  stylesheetRelsByFromAsset
+) {
+  const accumulatedFontFaceDeclarations = [];
+  const visitedAssets = new Set();
+  (function traverseForFontFace(asset) {
+    if (visitedAssets.has(asset)) return;
+    visitedAssets.add(asset);
+
+    if (asset.type === 'Css' && asset.isLoaded) {
+      const seenNodes = new Set();
+      const fontRelations = asset.outgoingRelations.filter(
+        (relation) => relation.type === 'CssFontFaceSrc'
+      );
 
-    // Compute accumulatedFontFaceDeclarations by traversing CSS relations
-    const accumulatedFontFaceDeclarations = [];
-    {
-      const visitedAssets = new Set();
-      (function traverseForFontFace(asset) {
-        if (visitedAssets.has(asset)) return;
-        visitedAssets.add(asset);
-
-        if (asset.type === 'Css' && asset.isLoaded) {
-          const seenNodes = new Set();
-          const fontRelations = asset.outgoingRelations.filter(
-            (relation) => relation.type === 'CssFontFaceSrc'
-          );
+      for (const fontRelation of fontRelations) {
+        const node = fontRelation.node;
+        if (seenNodes.has(node)) continue;
+        seenNodes.add(node);
 
-          for (const fontRelation of fontRelations) {
-            const node = fontRelation.node;
-            if (seenNodes.has(node)) continue;
-            seenNodes.add(node);
-
-            const fontFaceDeclaration = {
-              relations: fontRelations.filter((r) => r.node === node),
-              ...initialValueByProp,
-            };
-
-            node.walkDecls((declaration) => {
-              const propName = declaration.prop.toLowerCase();
-              fontFaceDeclaration[propName] =
-                propName === 'font-family'
-                  ? cssFontParser.parseFontFamily(declaration.value)[0]
-                  : declaration.value;
-            });
-            // Disregard incomplete @font-face declarations (must contain font-family and src per spec):
-            if (fontFaceDeclaration['font-family'] && fontFaceDeclaration.src) {
-              accumulatedFontFaceDeclarations.push(fontFaceDeclaration);
-            }
-          }
-        }
+        const fontFaceDeclaration = {
+          relations: fontRelations.filter((r) => r.node === node),
+          ...initialValueByProp,
+        };
 
-        // Traverse children using the pre-built index
-        const rels = stylesheetRelsByFromAsset.get(asset) || [];
-        for (const rel of rels) {
-          if (
-            fontFaceTraversalTypes.has(rel.type) ||
-            (rel.to && rel.to.type === 'Html' && rel.to.isInline)
-          ) {
-            traverseForFontFace(rel.to);
-          }
+        node.walkDecls((declaration) => {
+          const propName = declaration.prop.toLowerCase();
+          fontFaceDeclaration[propName] =
+            propName === 'font-family'
+              ? cssFontParser.parseFontFamily(declaration.value)[0]
+              : declaration.value;
+        });
+        // Disregard incomplete @font-face declarations (must contain font-family and src per spec):
+        if (fontFaceDeclaration['font-family'] && fontFaceDeclaration.src) {
+          accumulatedFontFaceDeclarations.push(fontFaceDeclaration);
         }
-      })(htmlOrSvgAsset);
+      }
     }
 
-    // Group @font-face declarations that share family/style/weight but have
-    // different unicode-range values. Each group's members cover a disjoint
-    // subset of the Unicode space (common for CJK / large character-set fonts).
-    const comboGroups = new Map();
-    for (const fontFace of accumulatedFontFaceDeclarations) {
-      const comboKey = `${fontFace['font-family']}/${fontFace['font-style']}/${fontFace['font-weight']}`;
-      if (!comboGroups.has(comboKey)) comboGroups.set(comboKey, []);
-      comboGroups.get(comboKey).push(fontFace);
-    }
-    for (const [comboKey, group] of comboGroups) {
-      if (group.length <= 1) continue;
-      const withoutRange = group.filter((d) => !d['unicode-range']);
-      if (withoutRange.length > 0) {
-        throw new Error(
-          `Multiple @font-face with the same font-family/font-style/font-weight combo but missing unicode-range on ${withoutRange.length} of ${group.length} declarations: ${comboKey}`
-        );
+    const rels = stylesheetRelsByFromAsset.get(asset) || [];
+    for (const rel of rels) {
+      if (
+        fontFaceTraversalTypes.has(rel.type) ||
+        (rel.to && rel.to.type === 'Html' && rel.to.isInline)
+      ) {
+        traverseForFontFace(rel.to);
       }
     }
+  })(htmlOrSvgAsset);
+  return accumulatedFontFaceDeclarations;
+}
 
-    const featureTagsByFamily = new Map();
-    const fontFamiliesWithFeatureSettings = findFontFamiliesWithFeatureSettings(
-      stylesheetsWithPredicates,
-      featureTagsByFamily
-    );
-
-    const result = {
-      accumulatedFontFaceDeclarations,
-      stylesheetsWithPredicates,
-      fontFamiliesWithFeatureSettings,
-      featureTagsByFamily,
-      fastPathKey: buildStylesheetKey(htmlOrSvgAsset, true),
-    };
-    stylesheetResultCache.set(key, result);
-    return result;
+// Validate that @font-face declarations sharing family/style/weight carry
+// disjoint unicode-range values; throws on incomplete coverage.
+function validateFontFaceComboCoverage(accumulatedFontFaceDeclarations) {
+  const comboGroups = new Map();
+  for (const fontFace of accumulatedFontFaceDeclarations) {
+    const comboKey = `${fontFace['font-family']}/${fontFace['font-style']}/${fontFace['font-weight']}`;
+    if (!comboGroups.has(comboKey)) comboGroups.set(comboKey, []);
+    comboGroups.get(comboKey).push(fontFace);
+  }
+  for (const [comboKey, group] of comboGroups) {
+    if (group.length <= 1) continue;
+    const withoutRange = group.filter((d) => !d['unicode-range']);
+    if (withoutRange.length > 0) {
+      throw new Error(
+        `Multiple @font-face with the same font-family/font-style/font-weight combo but missing unicode-range on ${withoutRange.length} of ${group.length} declarations: ${comboKey}`
+      );
+    }
   }
+}
 
-  const headlessBrowser =
-    dynamic && new HeadlessBrowser({ console, chromeArgs });
-  const globalTextByProps = [];
-  const subTimings = {};
+function computeStylesheetResults(htmlOrSvgAsset, stylesheetRelsByFromAsset) {
+  const stylesheetsWithPredicates = gatherStylesheetsWithPredicates(
+    htmlOrSvgAsset.assetGraph,
+    htmlOrSvgAsset,
+    stylesheetRelsByFromAsset
+  );
+
+  const accumulatedFontFaceDeclarations = collectFontFaceDeclarations(
+    htmlOrSvgAsset,
+    stylesheetRelsByFromAsset
+  );
+  validateFontFaceComboCoverage(accumulatedFontFaceDeclarations);
 
-  if (debug && console)
-    console.log('[subfont timing] collectTextsByPage started');
-  const timingStart = Date.now();
+  const featureTagsByFamily = new Map();
+  const fontFamiliesWithFeatureSettings = findFontFamiliesWithFeatureSettings(
+    stylesheetsWithPredicates,
+    featureTagsByFamily
+  );
 
-  // Pre-compute stylesheet results for all pages
-  const stylesheetPrecomputeStart = Date.now();
-  const pageData = [];
-  for (const htmlOrSvgAsset of htmlOrSvgAssets) {
-    const {
-      accumulatedFontFaceDeclarations,
-      stylesheetsWithPredicates,
-      fontFamiliesWithFeatureSettings,
-      featureTagsByFamily,
-      fastPathKey,
-    } = getOrComputeStylesheetResults(htmlOrSvgAsset);
-    fontFaceDeclarationsByHtmlOrSvgAsset.set(
+  return {
+    accumulatedFontFaceDeclarations,
+    stylesheetsWithPredicates,
+    fontFamiliesWithFeatureSettings,
+    featureTagsByFamily,
+    fastPathKey: buildStylesheetKey(
       htmlOrSvgAsset,
-      accumulatedFontFaceDeclarations
-    );
+      true,
+      stylesheetRelsByFromAsset
+    ),
+  };
+}
 
-    if (accumulatedFontFaceDeclarations.length === 0) {
-      continue;
-    }
+// Strip `-subfont-text` nodes from CSS @font-face declarations once the
+// subset planning is done, so they don't leak to the rendered output.
+function stripSubfontTextNodes(fontFaceDeclarationsByHtmlOrSvgAsset) {
+  for (const fontFaceDeclarations of fontFaceDeclarationsByHtmlOrSvgAsset.values()) {
+    for (const fontFaceDeclaration of fontFaceDeclarations) {
+      const firstRelation = fontFaceDeclaration.relations[0];
+      const subfontTextNode = firstRelation.node.nodes.find(
+        (childNode) =>
+          childNode.type === 'decl' &&
+          childNode.prop.toLowerCase() === '-subfont-text'
+      );
 
-    pageData.push({
-      htmlOrSvgAsset,
-      accumulatedFontFaceDeclarations,
-      stylesheetsWithPredicates,
-      fontFamiliesWithFeatureSettings,
-      featureTagsByFamily,
-      stylesheetCacheKey: fastPathKey,
-    });
+      if (subfontTextNode) {
+        subfontTextNode.remove();
+        firstRelation.from.markDirty();
+      }
+    }
   }
+}
 
-  if (debug && console)
-    console.log(
-      `[subfont timing] Stylesheet precompute: ${(subTimings['Stylesheet precompute'] = Date.now() - stylesheetPrecomputeStart)}ms (${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.
+// Split trace work: with a headless browser every page needs a full trace
+// (dynamic content); otherwise one representative per stylesheet group is
+// traced and the rest use fast-path text extraction.
+function planTracing(pageData, hasHeadlessBrowser) {
   const pagesByStylesheetKey = new Map();
   for (const pd of pageData) {
     let group = pagesByStylesheetKey.get(pd.stylesheetCacheKey);
@@ -986,7 +739,7 @@ async function collectTextsByPage(
 
   const pagesNeedingFullTrace = [];
   const fastPathPages = [];
-  if (headlessBrowser) {
+  if (hasHeadlessBrowser) {
     for (const pd of pageData) {
       pagesNeedingFullTrace.push(pd);
     }
@@ -1000,91 +753,37 @@ async function collectTextsByPage(
     }
   }
 
-  if (debug && console)
-    console.log(
-      `[subfont timing] CSS groups: ${pagesByStylesheetKey.size} unique, ${pagesNeedingFullTrace.length} to trace, ${fastPathPages.length} fast-path`
-    );
-
-  const tracingStart = Date.now();
-  try {
-    await tracePages(pagesNeedingFullTrace, {
-      headlessBrowser,
-      concurrency,
-      console,
-      memoizedGetCssRulesByProperty,
-    });
-
-    subTimings['Full tracing'] = Date.now() - tracingStart;
-    if (debug && console)
-      console.log(
-        `[subfont timing] Full tracing (${pagesNeedingFullTrace.length} pages): ${subTimings['Full tracing']}ms`
-      );
-
-    processFastPathPages(fastPathPages, {
-      memoizedGetCssRulesByProperty,
-      console,
-      debug,
-      subTimings,
-    });
-
-    const assembleStart = Date.now();
-    for (const pd of pageData) {
-      for (const textByPropsEntry of pd.textByProps) {
-        textByPropsEntry.htmlOrSvgAsset = pd.htmlOrSvgAsset;
-      }
-      // Use a loop instead of push(...spread) to avoid stack overflow on large sites
-      for (const entry of pd.textByProps) {
-        globalTextByProps.push(entry);
-      }
-      htmlOrSvgAssetTextsWithProps.push({
-        htmlOrSvgAsset: pd.htmlOrSvgAsset,
-        textByProps: pd.textByProps,
-        accumulatedFontFaceDeclarations: pd.accumulatedFontFaceDeclarations,
-        fontFamiliesWithFeatureSettings: pd.fontFamiliesWithFeatureSettings,
-        featureTagsByFamily: pd.featureTagsByFamily,
-      });
-    }
-
-    subTimings['Result assembly'] = Date.now() - assembleStart;
-    if (debug && console) {
-      console.log(
-        `[subfont timing] Result assembly: ${subTimings['Result assembly']}ms`
-      );
-      console.log(
-        `[subfont timing] Total tracing+extraction+assembly: ${
-          Date.now() - tracingStart
-        }ms`
-      );
-    }
-  } finally {
-    if (headlessBrowser) {
-      await headlessBrowser.close();
-    }
-  }
-
-  const postProcessStart = Date.now();
+  return {
+    pagesNeedingFullTrace,
+    fastPathPages,
+    uniqueGroupCount: pagesByStylesheetKey.size,
+  };
+}
 
-  // Consolidated cache for per-declarations-key data.
+// Iterate every traced page, snap its text against the @font-face set, and
+// emit fully-formed per-page fontUsages (one entry per font URL + props).
+// Caching is per declarations-key (declCache) and per raw pageText
+// (uniqueCharsCache) so sites with many similar pages stay linear.
+function buildPerPageFontUsages(
+  htmlOrSvgAssetTextsWithProps,
+  globalTextByProps,
+  text
+) {
   const declCache = new Map();
-
-  const perPageLoopStart = Date.now();
+  const uniqueCharsCache = new Map();
   let snappingTime = 0;
   let globalUsageTime = 0;
-
-  // Cache uniqueChars results by raw pageText string to avoid recomputing
-  const uniqueCharsCache = new Map();
   let cloningTime = 0;
 
-  for (const htmlOrSvgAssetTextsWithPropsEntry of htmlOrSvgAssetTextsWithProps) {
+  for (const entry of htmlOrSvgAssetTextsWithProps) {
     const {
       htmlOrSvgAsset,
       textByProps,
       accumulatedFontFaceDeclarations,
       fontFamiliesWithFeatureSettings,
       featureTagsByFamily,
-    } = htmlOrSvgAssetTextsWithPropsEntry;
+    } = entry;
 
-    // Get or compute the snapped global entries for this declarations set
     const declKey = getDeclarationsKey(accumulatedFontFaceDeclarations);
     if (!declCache.has(declKey)) {
       const snapStart = Date.now();
@@ -1100,108 +799,260 @@ async function collectTextsByPage(
       snappingTime += Date.now() - snapStart;
     }
 
-    // Precompute global font usage templates and indices once per declarations key
     const declCacheEntry = declCache.get(declKey);
     const globalUsageStart = Date.now();
-    getOrComputeGlobalFontUsages(
+    populateGlobalFontUsages(
       declCacheEntry,
       accumulatedFontFaceDeclarations,
       text
     );
     globalUsageTime += Date.now() - globalUsageStart;
 
-    const fontUsageTemplates = declCacheEntry.fontUsageTemplates;
-    const pageTextIndex = declCacheEntry.pageTextIndex;
-    const textAndPropsToFontUrl = declCacheEntry.preloadIndex;
+    const {
+      fontUsageTemplates,
+      pageTextIndex,
+      preloadIndex: textAndPropsToFontUrl,
+    } = declCacheEntry;
 
-    // Compute preload per fontUrl using inverted index
     const preloadFontUrls = new Set();
-    for (const entry of textByProps) {
-      const fontUrl = textAndPropsToFontUrl.get(entry);
+    for (const textByPropsEntry of textByProps) {
+      const fontUrl = textAndPropsToFontUrl.get(textByPropsEntry);
       if (fontUrl) {
         preloadFontUrls.add(fontUrl);
       }
     }
 
-    // Build per-page fontUsages from precomputed templates
     const cloneStart = Date.now();
     const assetTexts = pageTextIndex.get(htmlOrSvgAsset);
-    htmlOrSvgAssetTextsWithPropsEntry.fontUsages = fontUsageTemplates.map(
-      (template) => {
-        const pageTexts = assetTexts
-          ? assetTexts.get(template.fontUrl)
-          : undefined;
-        let pageTextStr = pageTexts ? pageTexts.join('') : '';
-        if (template.extraTextsStr) {
-          pageTextStr += template.extraTextsStr;
-        }
+    entry.fontUsages = fontUsageTemplates.map((template) => {
+      const pageTexts = assetTexts
+        ? assetTexts.get(template.fontUrl)
+        : undefined;
+      let pageTextStr = pageTexts ? pageTexts.join('') : '';
+      if (template.extraTextsStr) {
+        pageTextStr += template.extraTextsStr;
+      }
 
-        let pageTextUnique = uniqueCharsCache.get(pageTextStr);
-        if (pageTextUnique === undefined) {
-          pageTextUnique = uniqueChars(pageTextStr);
-          uniqueCharsCache.set(pageTextStr, pageTextUnique);
-        }
+      let pageTextUnique = uniqueCharsCache.get(pageTextStr);
+      if (pageTextUnique === undefined) {
+        pageTextUnique = uniqueChars(pageTextStr);
+        uniqueCharsCache.set(pageTextStr, pageTextUnique);
+      }
 
-        const { hasFontFeatureSettings, fontFeatureTags } =
-          resolveFeatureSettings(
-            template.fontFamilies,
-            fontFamiliesWithFeatureSettings,
-            featureTagsByFamily
-          );
+      const { hasFontFeatureSettings, fontFeatureTags } =
+        resolveFeatureSettings(
+          template.fontFamilies,
+          fontFamiliesWithFeatureSettings,
+          featureTagsByFamily
+        );
 
-        return {
-          smallestOriginalSize: template.smallestOriginalSize,
-          smallestOriginalFormat: template.smallestOriginalFormat,
-          texts: template.texts,
-          pageText: pageTextUnique,
-          text: template.text,
-          props: { ...template.props },
-          fontUrl: template.fontUrl,
-          fontFamilies: template.fontFamilies,
-          fontStyles: template.fontStyles,
-          fontStretches: template.fontStretches,
-          fontWeights: template.fontWeights,
-          fontVariationSettings: template.fontVariationSettings,
-          fontSizes: template.fontSizes,
-          preload: preloadFontUrls.has(template.fontUrl),
-          hasFontFeatureSettings,
-          fontFeatureTags,
-        };
-      }
-    );
+      return {
+        smallestOriginalSize: template.smallestOriginalSize,
+        smallestOriginalFormat: template.smallestOriginalFormat,
+        texts: template.texts,
+        pageText: pageTextUnique,
+        text: template.text,
+        props: { ...template.props },
+        fontUrl: template.fontUrl,
+        fontFamilies: template.fontFamilies,
+        fontStyles: template.fontStyles,
+        fontStretches: template.fontStretches,
+        fontWeights: template.fontWeights,
+        fontVariationSettings: template.fontVariationSettings,
+        preload: preloadFontUrls.has(template.fontUrl),
+        hasFontFeatureSettings,
+        fontFeatureTags,
+      };
+    });
     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)`
+  return { snappingTime, globalUsageTime, cloningTime };
+}
+
+// Run computeStylesheetResults once per page, memoizing the result across
+// pages that resolve to the same set of stylesheets. Pages without any
+// @font-face declarations are recorded in the declarations map but skipped
+// from pageData (nothing to trace or subset for them).
+function precomputeStylesheetsForPages(
+  htmlOrSvgAssets,
+  stylesheetRelsByFromAsset,
+  fontFaceDeclarationsByHtmlOrSvgAsset
+) {
+  const stylesheetResultCache = new Map();
+  const pageData = [];
+
+  for (const htmlOrSvgAsset of htmlOrSvgAssets) {
+    const key = buildStylesheetKey(
+      htmlOrSvgAsset,
+      false,
+      stylesheetRelsByFromAsset
     );
-  if (debug && console)
-    console.log(
-      `[subfont timing] Post-processing total: ${subTimings['Post-processing total']}ms`
+    let result = stylesheetResultCache.get(key);
+    if (!result) {
+      result = computeStylesheetResults(
+        htmlOrSvgAsset,
+        stylesheetRelsByFromAsset
+      );
+      stylesheetResultCache.set(key, result);
+    }
+
+    fontFaceDeclarationsByHtmlOrSvgAsset.set(
+      htmlOrSvgAsset,
+      result.accumulatedFontFaceDeclarations
     );
-  if (debug && console)
+
+    if (result.accumulatedFontFaceDeclarations.length === 0) {
+      continue;
+    }
+
+    pageData.push({
+      htmlOrSvgAsset,
+      accumulatedFontFaceDeclarations: result.accumulatedFontFaceDeclarations,
+      stylesheetsWithPredicates: result.stylesheetsWithPredicates,
+      fontFamiliesWithFeatureSettings: result.fontFamiliesWithFeatureSettings,
+      featureTagsByFamily: result.featureTagsByFamily,
+      stylesheetCacheKey: result.fastPathKey,
+    });
+  }
+
+  return pageData;
+}
+
+// Flatten traced per-page textByProps into a single globalTextByProps array,
+// tagging each entry with its owning asset so downstream code can map text
+// back to the page that rendered it.
+function flattenTracedPagesIntoGlobal(
+  pageData,
+  htmlOrSvgAssetTextsWithProps,
+  globalTextByProps
+) {
+  for (const pd of pageData) {
+    for (const textByPropsEntry of pd.textByProps) {
+      textByPropsEntry.htmlOrSvgAsset = pd.htmlOrSvgAsset;
+    }
+    // Use a loop instead of push(...spread) to avoid stack overflow on large sites
+    for (const entry of pd.textByProps) {
+      globalTextByProps.push(entry);
+    }
+    htmlOrSvgAssetTextsWithProps.push({
+      htmlOrSvgAsset: pd.htmlOrSvgAsset,
+      textByProps: pd.textByProps,
+      accumulatedFontFaceDeclarations: pd.accumulatedFontFaceDeclarations,
+      fontFamiliesWithFeatureSettings: pd.fontFamiliesWithFeatureSettings,
+      featureTagsByFamily: pd.featureTagsByFamily,
+    });
+  }
+}
+
+async function collectTextsByPage(
+  assetGraph,
+  htmlOrSvgAssets,
+  {
+    text,
+    console,
+    dynamic = false,
+    debug = false,
+    concurrency,
+    chromeArgs = [],
+  } = {}
+) {
+  const htmlOrSvgAssetTextsWithProps = [];
+  const memoizedGetCssRulesByProperty = memoizeSync(getCssRulesByProperty);
+  const fontFaceDeclarationsByHtmlOrSvgAsset = new Map();
+  const stylesheetRelsByFromAsset = indexStylesheetRelations(assetGraph);
+
+  const headlessBrowser =
+    dynamic && new HeadlessBrowser({ console, chromeArgs });
+  const globalTextByProps = [];
+  const subTimings = {};
+
+  const trackPhase = makePhaseTracker(console, debug);
+  const overallPhase = trackPhase('collectTextsByPage');
+
+  const stylesheetPrecompute = trackPhase('Stylesheet precompute');
+  const pageData = precomputeStylesheetsForPages(
+    htmlOrSvgAssets,
+    stylesheetRelsByFromAsset,
+    fontFaceDeclarationsByHtmlOrSvgAsset
+  );
+  subTimings['Stylesheet precompute'] = stylesheetPrecompute.end(
+    `${pageData.length} pages with fonts`
+  );
+
+  // Pages sharing the same CSS configuration produce identical font-tracer
+  // props, only text differs — so we trace one representative and fast-path
+  // the rest. With --dynamic every page is traced individually.
+  const { pagesNeedingFullTrace, fastPathPages, uniqueGroupCount } =
+    planTracing(pageData, Boolean(headlessBrowser));
+
+  // 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] collectTextsByPage total: ${Date.now() - timingStart}ms`
+      `  ${pageData.length} pages with fonts: ${pagesNeedingFullTrace.length} to trace, ${fastPathPages.length} via cached CSS group (${uniqueGroupCount} unique groups)`
     );
+  }
 
-  for (const fontFaceDeclarations of fontFaceDeclarationsByHtmlOrSvgAsset.values()) {
-    for (const fontFaceDeclaration of fontFaceDeclarations) {
-      const firstRelation = fontFaceDeclaration.relations[0];
-      const subfontTextNode = firstRelation.node.nodes.find(
-        (childNode) =>
-          childNode.type === 'decl' &&
-          childNode.prop.toLowerCase() === '-subfont-text'
-      );
+  const tracingStart = Date.now();
+  const fullTracing = trackPhase(
+    `Full tracing (${pagesNeedingFullTrace.length} pages)`
+  );
+  try {
+    await tracePages(pagesNeedingFullTrace, {
+      headlessBrowser,
+      concurrency,
+      console,
+      memoizedGetCssRulesByProperty,
+      debug,
+    });
 
-      if (subfontTextNode) {
-        subfontTextNode.remove();
-        firstRelation.from.markDirty();
-      }
+    subTimings['Full tracing'] = fullTracing.end();
+
+    const fastPathPhase = trackPhase('Fast-path extraction');
+    const fastPathFallbacks = processFastPathPages(fastPathPages, {
+      memoizedGetCssRulesByProperty,
+    });
+    subTimings['Fast-path extraction'] = fastPathPhase.end(
+      `${fastPathPages.length} pages, ${fastPathFallbacks} fell back to full trace`
+    );
+
+    const assemblePhase = trackPhase('Result assembly');
+    flattenTracedPagesIntoGlobal(
+      pageData,
+      htmlOrSvgAssetTextsWithProps,
+      globalTextByProps
+    );
+    subTimings['Result assembly'] = assemblePhase.end();
+    if (debug && console) {
+      console.log(
+        `[subfont timing] Total tracing+extraction+assembly: ${
+          Date.now() - tracingStart
+        }ms`
+      );
+    }
+  } finally {
+    if (headlessBrowser) {
+      await headlessBrowser.close();
     }
   }
+
+  const postProcessPhase = trackPhase('Post-processing total');
+  const perPageLoopPhase = trackPhase('Per-page loop');
+  const { snappingTime, globalUsageTime, cloningTime } = buildPerPageFontUsages(
+    htmlOrSvgAssetTextsWithProps,
+    globalTextByProps,
+    text
+  );
+  subTimings['Per-page loop'] = perPageLoopPhase.end(
+    `snapping: ${snappingTime}ms, globalUsage: ${globalUsageTime}ms, cloning: ${cloningTime}ms`
+  );
+  subTimings['Post-processing total'] = postProcessPhase.end();
+  overallPhase.end();
+
+  stripSubfontTextNodes(fontFaceDeclarationsByHtmlOrSvgAsset);
   return {
     htmlOrSvgAssetTextsWithProps,
     fontFaceDeclarationsByHtmlOrSvgAsset,
@@ -1210,9 +1061,3 @@ async function collectTextsByPage(
 }
 
 module.exports = collectTextsByPage;
-
-// Exported for testing only
-module.exports._extractFeatureTagsFromDecl = extractFeatureTagsFromDecl;
-module.exports._resolveFeatureSettings = resolveFeatureSettings;
-module.exports._findFontFamiliesWithFeatureSettings =
-  findFontFamiliesWithFeatureSettings;