@turntrout/subfont 1.10.2 → 1.10.3

package/lib/subfont.js

@@ -49,21 +49,7 @@ class UsageError extends Error {
         this.name = 'UsageError';
     }
 }
-const subfont = async function subfont({ root, canonicalRoot, output, debug = false, dryRun = false, silent = false, inlineCss = false, fontDisplay = 'swap', inPlace = false, inputFiles = [], recursive = false, relativeUrls = false, dynamic = false, fallbacks = true, text, sourceMaps = false, concurrency, chromeFlags = [], cache = false, strict = false, }, console) {
-    if (concurrency !== undefined &&
-        (!Number.isInteger(concurrency) || concurrency < 1)) {
-        throw new UsageError('--concurrency must be a positive integer');
-    }
-    // Prevent postcss plugins (colormin, convert-values, etc.) invoked by
-    // cssnano from walking the filesystem for a "browserslist" config.
-    // Under pnpm, `node_modules/.bin/browserslist` is a shell shim that
-    // browserslist mis-parses as browser queries, throwing
-    // BrowserslistError and silently aborting CSS minification.
-    // Setting BROWSERSLIST short-circuits the walk entirely.
-    if (!process.env.BROWSERSLIST && !process.env.BROWSERSLIST_CONFIG) {
-        process.env.BROWSERSLIST = 'defaults';
-    }
-    const formats = ['woff2'];
+function makeLogger(silent, console) {
     // Variadic console-style helpers: console.log / .warn accept any argument.
     /* eslint-disable no-restricted-syntax */
     function logToConsole(severity, ...args) {
@@ -71,20 +57,15 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
             console[severity](...args);
         }
     }
-    function log(...args) {
-        logToConsole('log', ...args);
-    }
-    function warn(...args) {
-        logToConsole('warn', ...args);
-    }
+    return {
+        log: (...args) => logToConsole('log', ...args),
+        warn: (...args) => logToConsole('warn', ...args),
+    };
     /* eslint-enable no-restricted-syntax */
-    const maxConcurrency = (0, concurrencyLimit_1.getMaxConcurrency)();
-    if (concurrency !== undefined && concurrency > maxConcurrency) {
-        warn(`--concurrency ${concurrency} exceeds estimated safe limit of ${maxConcurrency} (each worker uses ~50 MB; ${Math.round(os.freemem() / (1024 * 1024 * 1024))} GB free, ${os.cpus().length} CPUs). Proceeding anyway — reduce if you hit OOM.`);
-    }
-    let rootUrl = root && urlTools.urlOrFsPathToUrl(root, true);
+}
+async function resolveInputUrls(inputFiles, rootUrl, warn) {
     // Validate --root path exists early to give a clear error message
-    if (root && rootUrl && rootUrl.startsWith('file:')) {
+    if (rootUrl && rootUrl.startsWith('file:')) {
         const rootPath = urlTools.fileUrlToFsPath(rootUrl);
         try {
             await fsPromises.access(rootPath);
@@ -93,7 +74,6 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
             throw new UsageError(`The --root path does not exist: ${rootPath}`);
         }
     }
-    const outRoot = output && urlTools.urlOrFsPathToUrl(output, true);
     let inputUrls;
     if (inputFiles.length > 0) {
         inputUrls = inputFiles.map((urlOrFsPath) => urlTools.urlOrFsPathToUrl(String(urlOrFsPath), false));
@@ -116,61 +96,45 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
     else {
         throw new UsageError("No input files and no --root specified (or it isn't file:), cannot proceed.\n");
     }
-    if (!inputUrls[0].startsWith('file:') && !outRoot && !dryRun) {
-        throw new UsageError('--output has to be specified when using non-file input urls');
-    }
-    if (!inPlace && !outRoot && !dryRun) {
-        throw new UsageError('Either --output, --in-place, or --dry-run has to be specified');
-    }
-    const assetGraphConfig = {
-        root: rootUrl,
-        canonicalRoot,
+    return { inputUrls, rootUrl };
+}
+// Subfont only needs to follow CSS-related relations during populate.
+const cssRelatedTypes = [
+    'HtmlStyle',
+    'SvgStyle',
+    'CssImport',
+    'CssFontFaceSrc',
+    'HttpRedirect',
+    'HtmlMetaRefresh',
+    'HtmlConditionalComment',
+    'HtmlNoscript',
+];
+function buildFollowRelationsQuery(recursive) {
+    if (!recursive) {
+        return { type: { $in: cssRelatedTypes } };
+    }
+    return {
+        $or: [
+            { type: { $in: cssRelatedTypes } },
+            {
+                type: { $in: [...cssRelatedTypes, 'HtmlAnchor', 'SvgAnchor'] },
+                crossorigin: false,
+            },
+        ],
     };
-    if (rootUrl && !rootUrl.startsWith('file:')) {
-        assetGraphConfig.canonicalRoot = rootUrl.replace(/\/?$/, '/'); // Ensure trailing slash
-    }
-    // Subfont only needs to follow CSS-related relations during populate.
-    const cssRelatedTypes = [
-        'HtmlStyle',
-        'SvgStyle',
-        'CssImport',
-        'CssFontFaceSrc',
-        'HttpRedirect',
-        'HtmlMetaRefresh',
-        'HtmlConditionalComment',
-        'HtmlNoscript',
-    ];
-    let followRelationsQuery;
-    if (recursive) {
-        followRelationsQuery = {
-            $or: [
-                {
-                    type: { $in: cssRelatedTypes },
-                },
-                {
-                    type: { $in: [...cssRelatedTypes, 'HtmlAnchor', 'SvgAnchor'] },
-                    crossorigin: false,
-                },
-            ],
-        };
-    }
-    else {
-        followRelationsQuery = {
-            type: { $in: cssRelatedTypes },
-        };
-    }
-    const assetGraph = new AssetGraph(assetGraphConfig);
-    // Catch-clause idiom: error values are `unknown` until narrowed.
+}
+// Catch-clause idiom: error values are `unknown` until narrowed.
+// eslint-disable-next-line no-restricted-syntax
+function isExtensionlessEnoent(err) {
+    if (typeof err !== 'object' || err === null)
+        return false;
     // eslint-disable-next-line no-restricted-syntax
-    function isExtensionlessEnoent(err) {
-        if (typeof err !== 'object' || err === null)
-            return false;
-        // eslint-disable-next-line no-restricted-syntax
-        const e = err;
-        return (e.code === 'ENOENT' &&
-            typeof e.path === 'string' &&
-            !/\.[^/]+$/.test(e.path));
-    }
+    const e = err;
+    return (e.code === 'ENOENT' &&
+        typeof e.path === 'string' &&
+        !/\.[^/]+$/.test(e.path));
+}
+async function installWarningHandlers(assetGraph, silent, strict, console) {
     let sawWarning = false;
     const origEmit = assetGraph.emit;
     // EventEmitter.emit forwards arbitrary varargs.
@@ -189,28 +153,18 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
     else {
         await assetGraph.logEvents({ console, stopOnWarning: strict });
     }
-    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 = (0, progress_1.makePhaseTracker)({ log }, debug);
-    const loadAssetsPhase = trackPhase('loadAssets');
-    await assetGraph.loadAssets(inputUrls);
-    outerTimings.loadAssets = loadAssetsPhase.end();
-    const populatePhase = trackPhase('populate (initial)');
-    await assetGraph.populate({
-        followRelations: followRelationsQuery,
-    });
-    outerTimings['populate (initial)'] = populatePhase.end();
+    return () => sawWarning;
+}
+function handleInitialRedirects(assetGraph) {
     const entrypointAssets = assetGraph.findAssets({ isInitial: true });
     const redirectOrigins = new Set();
     for (const relation of assetGraph.findRelations({ type: 'HttpRedirect' }).sort((a, b) => a.id - b.id)) {
-        if (relation.from.isInitial) {
-            assetGraph.info(new Error(`${relation.from.url} redirected to ${relation.to.url}`));
-            relation.to.isInitial = true;
-            relation.from.isInitial = false;
-            redirectOrigins.add(relation.to.origin);
-        }
+        if (!relation.from.isInitial)
+            continue;
+        assetGraph.info(new Error(`${relation.from.url} redirected to ${relation.to.url}`));
+        relation.to.isInitial = true;
+        relation.from.isInitial = false;
+        redirectOrigins.add(relation.to.origin);
     }
     if (entrypointAssets.length === redirectOrigins.size &&
         redirectOrigins.size === 1) {
@@ -220,53 +174,21 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
             assetGraph.root = newRoot;
         }
     }
-    const sizeableAssetQuery = {
-        isInline: false,
-        isLoaded: true,
-        type: {
-            $in: ['Html', 'Svg', 'Css', 'JavaScript'],
-        },
-    };
-    let sumSizesBefore = 0;
-    for (const asset of assetGraph.findAssets(sizeableAssetQuery)) {
-        sumSizesBefore += asset.rawSrc.length;
-    }
-    if (!sourceMaps) {
-        log('Skipping CSS source map processing for faster execution. Use --source-maps to preserve them.');
-    }
-    let cacheDir = null;
+}
+function resolveCacheDir(cache, rootUrl, warn) {
     if (cache && typeof cache === 'string' && cache.length > 0) {
-        cacheDir = cache;
+        return cache;
     }
-    else if (cache && rootUrl && rootUrl.startsWith('file:')) {
-        cacheDir = pathModule.join(urlTools.fileUrlToFsPath(rootUrl), '.subfont-cache');
+    if (cache && rootUrl && rootUrl.startsWith('file:')) {
+        return pathModule.join(urlTools.fileUrlToFsPath(rootUrl), '.subfont-cache');
     }
-    else if (cache) {
+    if (cache) {
         warn('--cache ignored: caching requires a local --root or an explicit cache path');
     }
-    const subsetPhase = trackPhase('subsetFonts total');
-    const { fontInfo, timings: subsetTimings } = await subsetFonts(assetGraph, {
-        inlineCss,
-        fontDisplay,
-        formats,
-        omitFallbacks: !fallbacks,
-        hrefType: relativeUrls ? 'relative' : 'rootRelative',
-        text,
-        dynamic,
-        console,
-        sourceMaps,
-        debug,
-        concurrency,
-        chromeArgs: chromeFlags,
-        cacheDir,
-    });
-    const subsetFontsTotal = subsetPhase.end();
-    const postProcessingPhase = trackPhase('post-subsetFonts processing');
-    let sumSizesAfter = 0;
-    for (const asset of assetGraph.findAssets(sizeableAssetQuery)) {
-        sumSizesAfter += asset.rawSrc.length;
-    }
-    // Omit function calls:
+    return null;
+}
+async function runPostProcessing(assetGraph, rootUrl) {
+    // Omit function calls
     for (const relation of assetGraph.findRelations({
         type: 'JavaScriptStaticUrl',
         to: { isLoaded: true },
@@ -279,11 +201,11 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
         isLoaded: true,
         type: 'Css',
     })) {
-        if (!asset.url.startsWith(assetGraph.root)) {
-            assetGraph.info(new Error(`Pulling down modified stylesheet ${asset.url}`));
-            const safeName = sanitizeFilename(asset.baseName || '', { replacement: '_' }) || 'index';
-            asset.url = `${assetGraph.root}subfont/${safeName}-${asset.md5Hex.slice(0, 10)}${asset.extension || asset.defaultExtension}`;
-        }
+        if (asset.url.startsWith(assetGraph.root))
+            continue;
+        assetGraph.info(new Error(`Pulling down modified stylesheet ${asset.url}`));
+        const safeName = sanitizeFilename(asset.baseName || '', { replacement: '_' }) || 'index';
+        asset.url = `${assetGraph.root}subfont/${safeName}-${asset.md5Hex.slice(0, 10)}${asset.extension || asset.defaultExtension}`;
     }
     if (rootUrl && !rootUrl.startsWith('file:')) {
         for (const relation of assetGraph.findRelations({
@@ -298,78 +220,98 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
             fileName: { $or: ['', undefined] },
         }, (asset) => `${asset.url.replace(/\/?$/, '/')}index${asset.defaultExtension}`);
     }
-    outerTimings['post-subsetFonts processing'] = postProcessingPhase.end();
-    if (strict && sawWarning) {
-        // In non-silent mode, assetgraph's logEvents normally exits earlier via
-        // stopOnWarning. This guard covers silent mode and warnings that slipped
-        // past a transform boundary.
-        throw new Error('subfont: --strict was set and one or more warnings were emitted; refusing to write output.');
-    }
-    const writePhase = trackPhase('writeAssetsToDisc');
-    if (!dryRun) {
-        await assetGraph.writeAssetsToDisc({
-            isLoaded: true,
-            isRedirect: { $ne: true },
-            url: (url) => url && url.startsWith(assetGraph.root),
-        }, outRoot, assetGraph.root);
-    }
-    outerTimings.writeAssetsToDisc = writePhase.end();
-    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: {
-                            original: fu.codepoints.original.length,
-                            used: fu.codepoints.used.length,
-                            unused: fu.codepoints.unused.length,
-                        },
-                        pageCount: 0,
-                        samplePages: [],
-                    };
-                    byVariant.set(key, entry);
-                }
-                entry.pageCount += 1;
-                if (entry.samplePages.length < SAMPLE_PAGES) {
-                    entry.samplePages.push(assetFileName);
-                }
+}
+// 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.
+function printVariantSummary(fontInfo, log) {
+    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: {
+                        original: fu.codepoints.original.length,
+                        used: fu.codepoints.used.length,
+                        unused: fu.codepoints.unused.length,
+                    },
+                    pageCount: 0,
+                    samplePages: [],
+                };
+                byVariant.set(key, entry);
             }
-        }
-        for (const entry of byVariant.values()) {
-            const remaining = entry.pageCount - entry.samplePages.length;
-            if (remaining > 0) {
-                entry.samplePages.push(`...and ${remaining} more`);
+            entry.pageCount += 1;
+            if (entry.samplePages.length < SAMPLE_PAGES) {
+                entry.samplePages.push(assetFileName);
             }
         }
-        log(`Font variants (aggregated across ${fontInfo.length} page${fontInfo.length === 1 ? '' : 's'}):`);
-        log(util.inspect([...byVariant.values()], false, 99));
     }
+    for (const entry of byVariant.values()) {
+        const remaining = entry.pageCount - entry.samplePages.length;
+        if (remaining > 0) {
+            entry.samplePages.push(`...and ${remaining} more`);
+        }
+    }
+    log(`Font variants (aggregated across ${fontInfo.length} page${fontInfo.length === 1 ? '' : 's'}):`);
+    log(util.inspect([...byVariant.values()], false, 99));
+}
+function buildInstancingSuffix(fontUsage) {
+    const numAxesReduced = fontUsage.numAxesReduced ?? 0;
+    const numAxesPinned = fontUsage.numAxesPinned ?? 0;
+    if (fontUsage.fullyInstanced) {
+        return ', fully instanced';
+    }
+    if (numAxesReduced === 0 && numAxesPinned === 0) {
+        return '';
+    }
+    const instancingInfos = [];
+    if (numAxesPinned > 0) {
+        instancingInfos.push(`${numAxesPinned} ${numAxesPinned === 1 ? 'axis' : 'axes'} pinned`);
+    }
+    if (numAxesReduced) {
+        instancingInfos.push(`${numAxesReduced}${numAxesPinned > 0 ? '' : numAxesReduced === 1 ? ' axis' : ' axes'} reduced`);
+    }
+    return `, partially instanced (${instancingInfos.join(', ')})`;
+}
+function describeFontUsageStatus(fontUsage, usedPad, originalPad) {
+    const variantShortName = `${fontUsage.props['font-weight']}${fontUsage.props['font-style'] === 'italic' ? 'i' : ' '}`;
+    let status = `    ${variantShortName}: ${String(fontUsage.codepoints.used.length).padStart(usedPad)}/${String(fontUsage.codepoints.original.length).padStart(originalPad)} codepoints used`;
+    if (fontUsage.codepoints.page.length !== fontUsage.codepoints.used.length) {
+        status += ` (${fontUsage.codepoints.page.length} on this page)`;
+    }
+    let savings = 0;
+    if (fontUsage.smallestSubsetSize !== undefined) {
+        status += buildInstancingSuffix(fontUsage);
+        status += `, ${prettyBytes(fontUsage.smallestOriginalSize)} (${fontUsage.smallestOriginalFormat}) => ${prettyBytes(fontUsage.smallestSubsetSize)} (${fontUsage.smallestSubsetFormat})`;
+        savings = fontUsage.smallestOriginalSize - fontUsage.smallestSubsetSize;
+    }
+    else {
+        status += ', no subset font created';
+    }
+    return { status, savings };
+}
+function printPerAssetFontReport(fontInfo, sumSizesBefore, sumSizesAfter, log) {
     let totalSavings = sumSizesBefore - sumSizesAfter;
     for (const { assetFileName, fontUsages } of fontInfo) {
         let sumSmallestSubsetSize = 0;
@@ -396,45 +338,15 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
         for (const fontFamily of Object.keys(fontUsagesByFontFamily).sort()) {
             log(`  ${fontFamily}:`);
             for (const fontUsage of fontUsagesByFontFamily[fontFamily]) {
-                const variantShortName = `${fontUsage.props['font-weight']}${fontUsage.props['font-style'] === 'italic' ? 'i' : ' '}`;
-                let status = `    ${variantShortName}: ${String(fontUsage.codepoints.used.length).padStart(usedPad)}/${String(fontUsage.codepoints.original.length).padStart(originalPad)} codepoints used`;
-                if (fontUsage.codepoints.page.length !== fontUsage.codepoints.used.length) {
-                    status += ` (${fontUsage.codepoints.page.length} on this page)`;
-                }
-                if (fontUsage.smallestSubsetSize !== undefined) {
-                    const numAxesReduced = fontUsage.numAxesReduced ?? 0;
-                    const numAxesPinned = fontUsage.numAxesPinned ?? 0;
-                    if (fontUsage.fullyInstanced) {
-                        status += ', fully instanced';
-                    }
-                    else if (numAxesReduced > 0 || numAxesPinned) {
-                        const instancingInfos = [];
-                        if (numAxesPinned > 0) {
-                            instancingInfos.push(`${numAxesPinned} ${numAxesPinned === 1 ? 'axis' : 'axes'} pinned`);
-                        }
-                        if (numAxesReduced) {
-                            instancingInfos.push(`${numAxesReduced}${numAxesPinned > 0
-                                ? ''
-                                : numAxesReduced === 1
-                                    ? ' axis'
-                                    : ' axes'} reduced`);
-                        }
-                        status += `, partially instanced (${instancingInfos.join(', ')})`;
-                    }
-                    status += `, ${prettyBytes(fontUsage.smallestOriginalSize)} (${fontUsage.smallestOriginalFormat}) => ${prettyBytes(fontUsage.smallestSubsetSize)} (${fontUsage.smallestSubsetFormat})`;
-                    totalSavings +=
-                        fontUsage.smallestOriginalSize - fontUsage.smallestSubsetSize;
-                }
-                else {
-                    status += ', no subset font created';
-                }
+                const { status, savings } = describeFontUsageStatus(fontUsage, usedPad, originalPad);
+                totalSavings += savings;
                 log(status);
             }
         }
     }
-    log(`HTML/SVG/JS/CSS size increase: ${prettyBytes(sumSizesAfter - sumSizesBefore)}`);
-    log(`Total savings: ${prettyBytes(totalSavings)}`);
-    outerTimings['output reporting'] = reportingPhase.end();
+    return totalSavings;
+}
+function printTimingSummary(outerTimings, subsetFontsTotal, subsetTimings, log) {
     const st = subsetTimings ?? {};
     const detailsRaw = st.collectTextsByPageDetails;
     const details = detailsRaw && typeof detailsRaw === 'object' ? detailsRaw : {};
@@ -466,73 +378,197 @@ const subfont = async function subfont({ root, canonicalRoot, output, debug = fa
         ['writeAssetsToDisc', outerTimings.writeAssetsToDisc, 0],
         ['output reporting', outerTimings['output reporting'], 0],
     ];
-    if (debug) {
-        log('\n═══ Subfont Timing Summary ═══');
-        for (const [label, ms, indent] of rows) {
-            if (ms === undefined)
-                continue;
-            const prefix = '  '.repeat(indent + 1);
-            const padded = (ms || 0).toLocaleString().padStart(8);
-            log(`${prefix}${label}: ${padded}ms`);
+    log('\n═══ Subfont Timing Summary ═══');
+    for (const [label, ms, indent] of rows) {
+        if (ms === undefined)
+            continue;
+        const prefix = '  '.repeat(indent + 1);
+        const padded = (ms || 0).toLocaleString().padStart(8);
+        log(`${prefix}${label}: ${padded}ms`);
+    }
+    log('  ─────────────────────────────────');
+    log(`  Total: ${totalElapsed.toLocaleString().padStart(8)}ms`);
+    log('═══════════════════════════════\n');
+}
+function printDryRunPreview(assetGraph, log) {
+    log('\n═══ Dry Run Preview ═══');
+    const assetsToWrite = assetGraph.findAssets({
+        isLoaded: true,
+        isRedirect: { $ne: true },
+        url: (url) => url && url.startsWith(assetGraph.root),
+    });
+    const byType = {};
+    let totalOutputSize = 0;
+    for (const asset of assetsToWrite) {
+        const type = asset.type || 'Other';
+        if (!byType[type])
+            byType[type] = { count: 0, size: 0, files: [] };
+        const size = asset.rawSrc ? asset.rawSrc.length : 0;
+        byType[type].count += 1;
+        byType[type].size += size;
+        totalOutputSize += size;
+        if (asset.url && asset.url.includes('/subfont/')) {
+            byType[type].files.push(`    ${asset.url.replace(assetGraph.root, '/')} (${prettyBytes(size)})`);
         }
-        log('  ─────────────────────────────────');
-        log(`  Total: ${totalElapsed.toLocaleString().padStart(8)}ms`);
-        log('═══════════════════════════════\n');
     }
-    if (dryRun) {
-        log('\n═══ Dry Run Preview ═══');
-        const assetsToWrite = assetGraph.findAssets({
-            isLoaded: true,
-            isRedirect: { $ne: true },
-            url: (url) => url && url.startsWith(assetGraph.root),
-        });
-        const byType = {};
-        let totalOutputSize = 0;
-        for (const asset of assetsToWrite) {
-            const type = asset.type || 'Other';
-            if (!byType[type])
-                byType[type] = { count: 0, size: 0, files: [] };
-            const size = asset.rawSrc ? asset.rawSrc.length : 0;
-            byType[type].count += 1;
-            byType[type].size += size;
-            totalOutputSize += size;
-            if (asset.url && asset.url.includes('/subfont/')) {
-                byType[type].files.push(`    ${asset.url.replace(assetGraph.root, '/')} (${prettyBytes(size)})`);
-            }
+    for (const [type, info] of Object.entries(byType).sort(([, a], [, b]) => b.size - a.size)) {
+        log(`  ${type}: ${info.count} file${info.count === 1 ? '' : 's'}, ${prettyBytes(info.size)}`);
+        for (const file of info.files) {
+            log(file);
         }
-        for (const [type, info] of Object.entries(byType).sort(([, a], [, b]) => b.size - a.size)) {
-            log(`  ${type}: ${info.count} file${info.count === 1 ? '' : 's'}, ${prettyBytes(info.size)}`);
-            for (const file of info.files) {
-                log(file);
-            }
+    }
+    log(`  ─────────────────────────────────`);
+    log(`  Total output: ${prettyBytes(totalOutputSize)}`);
+    const dirtyHtmlAssets = assetGraph.findAssets({
+        isDirty: true,
+        isLoaded: true,
+        type: { $in: ['Html', 'Svg'] },
+    });
+    if (dirtyHtmlAssets.length > 0) {
+        log(`\n  Modified HTML/SVG files (${dirtyHtmlAssets.length}):`);
+        for (const asset of dirtyHtmlAssets) {
+            log(`    ${asset.urlOrDescription}`);
         }
-        log(`  ─────────────────────────────────`);
-        log(`  Total output: ${prettyBytes(totalOutputSize)}`);
-        const dirtyHtmlAssets = assetGraph.findAssets({
-            isDirty: true,
-            isLoaded: true,
-            type: { $in: ['Html', 'Svg'] },
-        });
-        if (dirtyHtmlAssets.length > 0) {
-            log(`\n  Modified HTML/SVG files (${dirtyHtmlAssets.length}):`);
-            for (const asset of dirtyHtmlAssets) {
-                log(`    ${asset.urlOrDescription}`);
-            }
+    }
+    const subsetCssAssets = assetGraph.findAssets({
+        type: 'Css',
+        isLoaded: true,
+        url: (url) => url && url.includes('/subfont/'),
+    });
+    if (subsetCssAssets.length > 0) {
+        log(`\n  Subset CSS files that would be created (${subsetCssAssets.length}):`);
+        for (const css of subsetCssAssets) {
+            const fontFaceCount = (css.text.match(/@font-face/g) || []).length;
+            log(`    ${css.url.replace(assetGraph.root, '/')} (${prettyBytes(css.rawSrc.length)}, ${fontFaceCount} @font-face rule${fontFaceCount === 1 ? '' : 's'})`);
         }
-        const subsetCssAssets = assetGraph.findAssets({
-            type: 'Css',
+    }
+    log('═══════════════════════════════\n');
+    log('Dry run complete — no files were written.');
+}
+async function resolveRootsAndInputs(root, output, inputFiles, inPlace, dryRun, warn) {
+    let rootUrl = root && urlTools.urlOrFsPathToUrl(root, true);
+    const outRoot = output && urlTools.urlOrFsPathToUrl(output, true);
+    const resolved = await resolveInputUrls(inputFiles, rootUrl, warn);
+    rootUrl = resolved.rootUrl;
+    const inputUrls = resolved.inputUrls;
+    if (!inputUrls[0].startsWith('file:') && !outRoot && !dryRun) {
+        throw new UsageError('--output has to be specified when using non-file input urls');
+    }
+    if (!inPlace && !outRoot && !dryRun) {
+        throw new UsageError('Either --output, --in-place, or --dry-run has to be specified');
+    }
+    return { rootUrl, outRoot, inputUrls };
+}
+function printRunReport(fontInfo, sumSizesBefore, sumSizesAfter, debug, log) {
+    if (debug)
+        printVariantSummary(fontInfo, log);
+    const totalSavings = printPerAssetFontReport(fontInfo, sumSizesBefore, sumSizesAfter, log);
+    log(`HTML/SVG/JS/CSS size increase: ${prettyBytes(sumSizesAfter - sumSizesBefore)}`);
+    log(`Total savings: ${prettyBytes(totalSavings)}`);
+}
+const subfont = async function subfont({ root, canonicalRoot, output, debug = false, dryRun = false, silent = false, inlineCss = false, fontDisplay = 'swap', inPlace = false, inputFiles = [], recursive = false, relativeUrls = false, dynamic = false, fallbacks = true, text, sourceMaps = false, concurrency, chromeFlags = [], cache = false, strict = false, }, console) {
+    if (concurrency !== undefined &&
+        (!Number.isInteger(concurrency) || concurrency < 1)) {
+        throw new UsageError('--concurrency must be a positive integer');
+    }
+    // Prevent postcss plugins (colormin, convert-values, etc.) invoked by
+    // cssnano from walking the filesystem for a "browserslist" config.
+    // Under pnpm, `node_modules/.bin/browserslist` is a shell shim that
+    // browserslist mis-parses as browser queries, throwing
+    // BrowserslistError and silently aborting CSS minification.
+    // Setting BROWSERSLIST short-circuits the walk entirely.
+    if (!process.env.BROWSERSLIST && !process.env.BROWSERSLIST_CONFIG) {
+        process.env.BROWSERSLIST = 'defaults';
+    }
+    const { log, warn } = makeLogger(silent, console);
+    const maxConcurrency = (0, concurrencyLimit_1.getMaxConcurrency)();
+    if (concurrency !== undefined && concurrency > maxConcurrency) {
+        warn(`--concurrency ${concurrency} exceeds estimated safe limit of ${maxConcurrency} (each worker uses ~50 MB; ${Math.round(os.freemem() / (1024 * 1024 * 1024))} GB free, ${os.cpus().length} CPUs). Proceeding anyway — reduce if you hit OOM.`);
+    }
+    const { rootUrl, outRoot, inputUrls } = await resolveRootsAndInputs(root, output, inputFiles, inPlace, dryRun, warn);
+    const assetGraph = new AssetGraph({
+        root: rootUrl,
+        // Non-file roots get an explicit trailing-slash canonicalRoot so
+        // relative-URL resolution lines up with how the deployed site reads.
+        canonicalRoot: rootUrl && !rootUrl.startsWith('file:')
+            ? rootUrl.replace(/\/?$/, '/')
+            : canonicalRoot,
+    });
+    const getSawWarning = await installWarningHandlers(assetGraph, silent, strict, console);
+    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 = (0, progress_1.makePhaseTracker)({ log }, debug);
+    const loadAssetsPhase = trackPhase('loadAssets');
+    await assetGraph.loadAssets(inputUrls);
+    outerTimings.loadAssets = loadAssetsPhase.end();
+    const populatePhase = trackPhase('populate (initial)');
+    await assetGraph.populate({
+        followRelations: buildFollowRelationsQuery(recursive),
+    });
+    outerTimings['populate (initial)'] = populatePhase.end();
+    handleInitialRedirects(assetGraph);
+    const sizeableAssetQuery = {
+        isInline: false,
+        isLoaded: true,
+        type: { $in: ['Html', 'Svg', 'Css', 'JavaScript'] },
+    };
+    let sumSizesBefore = 0;
+    for (const asset of assetGraph.findAssets(sizeableAssetQuery)) {
+        sumSizesBefore += asset.rawSrc.length;
+    }
+    if (!sourceMaps) {
+        log('Skipping CSS source map processing for faster execution. Use --source-maps to preserve them.');
+    }
+    const cacheDir = resolveCacheDir(cache, rootUrl, warn);
+    const subsetPhase = trackPhase('subsetFonts total');
+    const { fontInfo, timings: subsetTimings } = await subsetFonts(assetGraph, {
+        inlineCss,
+        fontDisplay,
+        formats: ['woff2'],
+        omitFallbacks: !fallbacks,
+        hrefType: relativeUrls ? 'relative' : 'rootRelative',
+        text,
+        dynamic,
+        console,
+        sourceMaps,
+        debug,
+        concurrency,
+        chromeArgs: chromeFlags,
+        cacheDir,
+    });
+    const subsetFontsTotal = subsetPhase.end();
+    const postProcessingPhase = trackPhase('post-subsetFonts processing');
+    let sumSizesAfter = 0;
+    for (const asset of assetGraph.findAssets(sizeableAssetQuery)) {
+        sumSizesAfter += asset.rawSrc.length;
+    }
+    await runPostProcessing(assetGraph, rootUrl);
+    outerTimings['post-subsetFonts processing'] = postProcessingPhase.end();
+    if (strict && getSawWarning()) {
+        // In non-silent mode, assetgraph's logEvents normally exits earlier via
+        // stopOnWarning. This guard covers silent mode and warnings that slipped
+        // past a transform boundary.
+        throw new Error('subfont: --strict was set and one or more warnings were emitted; refusing to write output.');
+    }
+    const writePhase = trackPhase('writeAssetsToDisc');
+    if (!dryRun) {
+        await assetGraph.writeAssetsToDisc({
             isLoaded: true,
-            url: (url) => url && url.includes('/subfont/'),
-        });
-        if (subsetCssAssets.length > 0) {
-            log(`\n  Subset CSS files that would be created (${subsetCssAssets.length}):`);
-            for (const css of subsetCssAssets) {
-                const fontFaceCount = (css.text.match(/@font-face/g) || []).length;
-                log(`    ${css.url.replace(assetGraph.root, '/')} (${prettyBytes(css.rawSrc.length)}, ${fontFaceCount} @font-face rule${fontFaceCount === 1 ? '' : 's'})`);
-            }
-        }
-        log('═══════════════════════════════\n');
-        log('Dry run complete — no files were written.');
+            isRedirect: { $ne: true },
+            url: (url) => url && url.startsWith(assetGraph.root),
+        }, outRoot, assetGraph.root);
+    }
+    outerTimings.writeAssetsToDisc = writePhase.end();
+    const reportingPhase = trackPhase('output reporting');
+    printRunReport(fontInfo, sumSizesBefore, sumSizesAfter, debug, log);
+    outerTimings['output reporting'] = reportingPhase.end();
+    if (debug) {
+        printTimingSummary(outerTimings, subsetFontsTotal, subsetTimings, log);
+    }
+    if (dryRun) {
+        printDryRunPreview(assetGraph, log);
     }
     else {
         log('Output written to', outRoot || assetGraph.root);