@stati/core 1.21.0 → 1.22.0

package/dist/config/loader.d.ts

@@ -1,4 +1,8 @@
 import type { StatiConfig } from '../types/index.js';
+/**
+ * Clear the config cache. Useful when config file changes are detected.
+ */
+export declare function clearConfigCache(): void;
 /**
  * Builds config file paths for a given directory.
  * @param cwd - Directory to search for config files

package/dist/config/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAiCrD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAExD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CA0ElF"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA6BrD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAqBD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAExD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CA6GlF"}

package/dist/config/loader.js

@@ -1,9 +1,20 @@
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { validateISGConfig, ISGConfigurationError } from '../core/isg/validation.js';
 import { compileStatiConfig, cleanupCompiledConfig } from '../core/utils/index.js';
 import { DEFAULT_SRC_DIR, DEFAULT_OUT_DIR, DEFAULT_STATIC_DIR, DEFAULT_SITE_TITLE, DEFAULT_DEV_BASE_URL, DEFAULT_TTL_SECONDS, DEFAULT_MAX_AGE_CAP_DAYS, CONFIG_FILE_PATTERNS, } from '../constants.js';
+/**
+ * Config cache to prevent repeated dynamic imports during dev server rebuilds.
+ * Key is the resolved config file path.
+ */
+const configCache = new Map();
+/**
+ * Clear the config cache. Useful when config file changes are detected.
+ */
+export function clearConfigCache() {
+    configCache.clear();
+}
 /**
  * Default configuration values for Stati.
  * Used as fallback when no configuration file is found.
@@ -62,14 +73,35 @@ export async function loadConfig(cwd = process.cwd()) {
     if (!configPath) {
         return DEFAULT_CONFIG;
     }
+    const resolvedConfigPath = resolve(configPath);
+    // Check if we have a cached config and if it's still valid
+    const cached = configCache.get(resolvedConfigPath);
+    if (cached) {
+        try {
+            const currentMtime = statSync(resolvedConfigPath).mtimeMs;
+            if (currentMtime === cached.mtime) {
+                // Config file hasn't changed, return cached version
+                return cached.config;
+            }
+            // Config changed, clear this cache entry
+            configCache.delete(resolvedConfigPath);
+        }
+        catch {
+            // If we can't stat the file, clear cache and reload
+            configCache.delete(resolvedConfigPath);
+        }
+    }
     try {
         let configModule;
         let compiledPath;
+        // Get current mtime for cache-busting
+        const currentMtime = statSync(resolvedConfigPath).mtimeMs;
         // If it's a .ts file, compile it first
         if (configPath.endsWith('.ts')) {
             try {
-                compiledPath = await compileStatiConfig(resolve(configPath));
-                const configUrl = pathToFileURL(compiledPath).href;
+                compiledPath = await compileStatiConfig(resolvedConfigPath);
+                // Add cache-busting query parameter to force Node.js to re-evaluate the module
+                const configUrl = `${pathToFileURL(compiledPath).href}?t=${currentMtime}`;
                 configModule = await import(configUrl);
             }
             finally {
@@ -81,7 +113,8 @@ export async function loadConfig(cwd = process.cwd()) {
         }
         else {
             // Existing logic for .js/.mjs
-            const configUrl = pathToFileURL(resolve(configPath)).href;
+            // Add cache-busting query parameter to force Node.js to re-evaluate the module
+            const configUrl = `${pathToFileURL(resolvedConfigPath).href}?t=${currentMtime}`;
             configModule = await import(configUrl);
         }
         const userConfig = configModule.default || configModule;
@@ -106,6 +139,18 @@ export async function loadConfig(cwd = process.cwd()) {
             }
             throw error; // Re-throw non-ISG errors
         }
+        // Cache the loaded config with its modification time
+        try {
+            const mtime = statSync(resolvedConfigPath).mtimeMs;
+            configCache.set(resolvedConfigPath, {
+                config: mergedConfig,
+                configPath: resolvedConfigPath,
+                mtime,
+            });
+        }
+        catch {
+            // If we can't stat, still return the config but don't cache
+        }
         return mergedConfig;
     }
     catch (error) {

package/dist/core/build.d.ts

@@ -46,6 +46,12 @@ export interface BuildOptions {
     coreVersion?: string | undefined;
     /** Metrics collection options */
     metrics?: MetricsOptions | undefined;
+    /** Skip updating cache entries after render (dev mode optimization) */
+    skipCacheUpdate?: boolean | undefined;
+    /** Skip saving cache manifest at end of build (dev mode optimization when caller already saved it) */
+    skipManifestSave?: boolean | undefined;
+    /** Skip copying static assets (dev mode optimization for template-only changes) */
+    skipAssetCopy?: boolean | undefined;
 }
 /**
  * Extended build result including optional metrics.

package/dist/core/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AAuDA,OAAO,KAAK,EAEV,UAAU,EACV,MAAM,EAQP,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,8BAA8B;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,+BAA+B;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,iCAAiC;IACjC,OAAO,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,wDAAwD;IACxD,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAkGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAW5E"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AA0DA,OAAO,KAAK,EAEV,UAAU,EACV,MAAM,EASP,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,8BAA8B;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,+BAA+B;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,iCAAiC;IACjC,OAAO,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACrC,uEAAuE;IACvE,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,sGAAsG;IACtG,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,mFAAmF;IACnF,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,wDAAwD;IACxD,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAkGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAsB5E"}

package/dist/core/build.js

@@ -1,4 +1,4 @@
-import { ensureDir, writeFile, remove, pathExists, stat, readdir, copyFile, resolveOutDir, resolveStaticDir, resolveCacheDir, enableInventoryTracking, disableInventoryTracking, clearInventory, writeTailwindClassInventory, getInventorySize, isTailwindUsed, loadPreviousInventory, compileTypeScript, autoInjectBundles, getBundlePathsForPage, formatBytes, } from './utils/index.js';
+import { ensureDir, writeFile, remove, pathExists, stat, readdir, copyFile, resolveOutDir, resolveStaticDir, resolveCacheDir, enableInventoryTracking, disableInventoryTracking, clearInventory, writeTailwindClassInventory, getInventorySize, isTailwindUsed, loadPreviousInventory, compileTypeScript, detectExistingBundles, autoInjectBundles, getBundlePathsForPage, formatBytes, } from './utils/index.js';
 import { join, dirname, relative, posix } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { loadConfig } from '../config/loader.js';
@@ -6,11 +6,11 @@ import { loadContent } from './content.js';
 import { createMarkdownProcessor, renderMarkdown, extractToc } from './markdown.js';
 import { createTemplateEngine, renderPage } from './templates.js';
 import { buildNavigation } from './navigation.js';
-import { loadCacheManifest, saveCacheManifest, shouldRebuildPage, createCacheEntry, updateCacheEntry, withBuildLock, computeNavigationHash, } from './isg/index.js';
+import { loadCacheManifest, saveCacheManifest, shouldRebuildPage, createCacheEntry, updateCacheEntry, withBuildLock, computeNavigationHash, clearFileHashCache, clearTemplatePathCache, } from './isg/index.js';
 import { generateSitemap, generateRobotsTxtFromConfig, autoInjectSEO, } from '../seo/index.js';
 import { generateRSSFeeds, validateRSSConfig } from '../rss/index.js';
 import { computeSearchIndexFilename, generateSearchIndex, writeSearchIndex, autoInjectSearchMeta, } from '../search/index.js';
-import { getEnv } from '../env.js';
+import { getEnv, isDevelopment } from '../env.js';
 import { DEFAULT_OUT_DIR } from '../constants.js';
 import { createMetricRecorder, noopMetricRecorder } from '../metrics/index.js';
 /**
@@ -133,10 +133,19 @@ const defaultLogger = {
  */
 export async function build(options = {}) {
     const cacheDir = resolveCacheDir();
+    // Clear per-build caches at the start of each build
+    // This prevents stale data from previous builds and ensures consistent state
+    clearFileHashCache();
+    clearTemplatePathCache();
     // Ensure cache directory exists before acquiring build lock
     await ensureDir(cacheDir);
+    // In dev mode, bypass file-based build lock (dev server handles concurrency via isBuildingRef
+    // and dev server lock prevents multiple dev servers in the same directory)
+    if (isDevelopment()) {
+        return buildInternal(options);
+    }
     // Use build lock to prevent concurrent builds, with force option to override
-    return await withBuildLock(cacheDir, () => buildInternal(options), {
+    return withBuildLock(cacheDir, () => buildInternal(options), {
         force: Boolean(options.force || options.clean), // Allow force if user explicitly requests it
         timeout: 60000, // 1 minute timeout
     });
@@ -218,6 +227,15 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
     if (logger.startProgress) {
         logger.startProgress(pages.length);
     }
+    // Track timing for shouldRebuildPage
+    let totalShouldRebuildTime = 0;
+    let totalRenderTime = 0;
+    let totalFileWriteTime = 0;
+    let totalCacheEntryTime = 0;
+    // Batch pending writes for parallel execution (dev mode optimization)
+    const isDevMode = isDevelopment();
+    const pendingWrites = [];
+    const pendingCacheUpdates = [];
     for (let i = 0; i < pages.length; i++) {
         const page = pages[i];
         if (!page)
@@ -238,7 +256,10 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
         const cacheKey = relativePath.startsWith('/') ? relativePath : `/${relativePath}`;
         const existingEntry = manifest.entries[cacheKey];
         // Check if we should rebuild this page (considering ISG logic)
+        const shouldRebuildStart = performance.now();
         const shouldRebuild = options.force || (await shouldRebuildPage(page, existingEntry, config, buildTime));
+        const shouldRebuildTime = performance.now() - shouldRebuildStart;
+        totalShouldRebuildTime += shouldRebuildTime;
         if (!shouldRebuild) {
             // Cache hit - skip rendering
             cacheHits++;
@@ -279,7 +300,10 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
             }),
         };
         // Render with template
+        const renderPageStart = performance.now();
         const renderResult = await renderPage(page, htmlContent, config, eta, navigation, pages, assets, toc, logger);
+        const renderPageTime = performance.now() - renderPageStart;
+        totalRenderTime += renderPageTime;
         let finalHtml = renderResult.html;
         // Record templates loaded for this page
         recorder.increment('templatesLoaded', renderResult.templatesLoaded);
@@ -312,15 +336,28 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
         if (logger.updateProgress) {
             logger.updateProgress('rendered', page.url, renderTime);
         }
-        // Ensure directory exists and write file
-        await ensureDir(dirname(outputPath));
-        await writeFile(outputPath, finalHtml, 'utf-8');
-        // Update cache manifest
-        if (existingEntry) {
-            manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, buildTime);
+        // In dev mode, batch writes for parallel execution to avoid Windows filesystem slowdown
+        if (isDevMode) {
+            pendingWrites.push({ outputPath, content: finalHtml });
+            pendingCacheUpdates.push({ cacheKey, page, existingEntry });
         }
         else {
-            manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime);
+            // Production mode: write immediately
+            const fileWriteStart = performance.now();
+            await ensureDir(dirname(outputPath));
+            await writeFile(outputPath, finalHtml, 'utf-8');
+            totalFileWriteTime += performance.now() - fileWriteStart;
+            // Update cache manifest
+            if (!options.skipCacheUpdate) {
+                const cacheEntryStart = performance.now();
+                if (existingEntry) {
+                    manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, buildTime);
+                }
+                else {
+                    manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime);
+                }
+                totalCacheEntryTime += performance.now() - cacheEntryStart;
+            }
         }
         // Collect searchable page data if search is enabled
         // Uses TOC entries and markdown content instead of parsing rendered HTML
@@ -334,6 +371,36 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
             recorder.addToPhase('hookAfterRenderTotalMs', performance.now() - hookStart);
         }
     }
+    // In dev mode, execute batched writes in parallel
+    if (isDevMode && pendingWrites.length > 0) {
+        const fileWriteStart = performance.now();
+        // Ensure all directories exist first
+        const uniqueDirs = [...new Set(pendingWrites.map((w) => dirname(w.outputPath)))];
+        await Promise.all(uniqueDirs.map((dir) => ensureDir(dir)));
+        // Write all files in parallel
+        await Promise.all(pendingWrites.map((w) => writeFile(w.outputPath, w.content, 'utf-8')));
+        totalFileWriteTime = performance.now() - fileWriteStart;
+        // Update cache entries SEQUENTIALLY with fast update (reuse existing deps)
+        // This avoids expensive template dependency tracking on each incremental rebuild
+        if (!options.skipCacheUpdate) {
+            const cacheEntryStart = performance.now();
+            for (const { cacheKey, page, existingEntry } of pendingCacheUpdates) {
+                if (existingEntry) {
+                    // Fast update: reuse existing deps, just update hashes and timestamp
+                    manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, buildTime, true);
+                }
+                else {
+                    manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime);
+                }
+            }
+            totalCacheEntryTime = performance.now() - cacheEntryStart;
+        }
+    }
+    // Record detailed phase timings in metrics
+    recorder.recordPhase('shouldRebuildTotalMs', totalShouldRebuildTime);
+    recorder.recordPhase('renderPageTotalMs', totalRenderTime);
+    recorder.recordPhase('fileWriteTotalMs', totalFileWriteTime);
+    recorder.recordPhase('cacheEntryTotalMs', totalCacheEntryTime);
     // Display final progress summary
     if (logger.endProgress) {
         logger.endProgress();
@@ -369,13 +436,17 @@ async function copyStaticAssets(config, outDir, logger) {
 /**
  * Generates build statistics.
  */
-async function generateBuildStats(pages, assetsCount, buildStartTime, outDir, cacheHits, cacheMisses, logger) {
+async function generateBuildStats(pages, assetsCount, buildStartTime, outDir, cacheHits, cacheMisses, logger, recorder = noopMetricRecorder) {
     const buildEndTime = Date.now();
+    const outputSizeStart = performance.now();
+    const outputSizeBytes = await getDirectorySize(outDir);
+    const dirSizeTime = performance.now() - outputSizeStart;
+    recorder.recordPhase('getDirectorySizeMs', dirSizeTime);
     const buildStats = {
         totalPages: pages.length,
         assetsCount,
         buildTimeMs: buildEndTime - buildStartTime,
-        outputSizeBytes: await getDirectorySize(outDir),
+        outputSizeBytes,
         // Include ISG cache statistics
         cacheHits,
         cacheMisses,
@@ -427,6 +498,7 @@ async function buildInternal(options = {}) {
     }
     await ensureDir(outDir);
     // Enable Tailwind class inventory tracking only if Tailwind is detected
+    const tailwindInitStart = performance.now();
     const hasTailwind = await isTailwindUsed();
     if (hasTailwind) {
         enableInventoryTracking();
@@ -447,6 +519,8 @@ async function buildInternal(options = {}) {
             logger.status(`Created inventory file for Tailwind scanner (will be populated after rendering)`);
         }
     }
+    const tailwindInitTime = performance.now() - tailwindInitStart;
+    recorder.recordPhase('tailwindInitMs', tailwindInitTime);
     // Load cache manifest for ISG (after potential clean operation)
     const endManifestLoadSpan = recorder.startSpan('cacheManifestLoadMs');
     const { manifest } = await setupCacheAndManifest(cacheDir);
@@ -466,22 +540,35 @@ async function buildInternal(options = {}) {
     // Store navigation hash in manifest for change detection in dev server
     manifest.navigationHash = navigationHash;
     // Compile TypeScript if enabled
+    // In dev mode, skip compilation since esbuild watcher handles it
     let compiledBundles = [];
-    if (config.typescript?.enabled) {
+    const isDevMode = isDevelopment();
+    if (config.typescript?.enabled && isDevMode) {
+        // In dev mode, detect existing bundles compiled by esbuild watcher
+        compiledBundles = await detectExistingBundles({
+            projectRoot: process.cwd(),
+            config: config.typescript,
+            outDir: config.outDir || DEFAULT_OUT_DIR,
+            mode: 'development',
+        });
+    }
+    else if (config.typescript?.enabled) {
         const endTsSpan = recorder.startSpan('typescriptCompileMs');
         compiledBundles = await compileTypeScript({
             projectRoot: process.cwd(),
             config: config.typescript,
             outDir: config.outDir || DEFAULT_OUT_DIR,
-            mode: getEnv() === 'production' ? 'production' : 'development',
+            mode: 'production',
             logger,
         });
         endTsSpan();
     }
     // Pre-compute search index filename if search is enabled
+    // In dev mode, use a stable filename to simlplify testing and debugging
     let searchIndexFilename;
     if (config.search?.enabled) {
-        searchIndexFilename = computeSearchIndexFilename(config.search, buildStartTime.toString());
+        const buildId = isDevMode ? 'dev' : buildStartTime.toString();
+        searchIndexFilename = computeSearchIndexFilename(config.search, buildId);
     }
     // Process pages with ISG caching logic
     if (logger.step) {
@@ -502,32 +589,46 @@ async function buildInternal(options = {}) {
         logger.info(`Generating search index to ${searchIndexFilename}`);
         const endSearchIndexSpan = recorder.startSpan('searchIndexGenerationMs');
         const searchIndex = generateSearchIndex(searchablePages, config.search);
-        searchIndexMetadata = await writeSearchIndex(searchIndex, outDir, searchIndexFilename);
         endSearchIndexSpan();
+        const writeStart = performance.now();
+        // In dev mode, skip write if content hasn't changed (template-only changes)
+        const skipIfUnchanged = isDevMode;
+        searchIndexMetadata = await writeSearchIndex(searchIndex, outDir, searchIndexFilename, skipIfUnchanged);
+        const writeTime = performance.now() - writeStart;
+        recorder.recordPhase('searchIndexWriteMs', writeTime);
         logger.success(`Generated search index with ${searchIndexMetadata.documentCount} documents`);
     }
     // Record page rendering counts
     recorder.increment('renderedPages', cacheMisses);
     recorder.increment('cachedPages', cacheHits);
     // Write Tailwind class inventory after all templates have been rendered (if Tailwind is used)
+    const tailwindStart = performance.now();
     if (hasTailwind) {
         const inventorySize = getInventorySize();
         if (inventorySize > 0) {
-            await writeTailwindClassInventory(cacheDir);
+            // In dev mode, skip write if inventory size hasn't changed
+            const skipIfUnchanged = isDevMode;
+            await writeTailwindClassInventory(cacheDir, skipIfUnchanged);
             logger.info('');
             logger.status(`Generated Tailwind class inventory (${inventorySize} classes tracked)`);
         }
         // Disable inventory tracking after build
         disableInventoryTracking();
     }
-    // Save updated cache manifest
+    const tailwindInventoryTime = performance.now() - tailwindStart;
+    recorder.recordPhase('tailwindInventoryMs', tailwindInventoryTime);
+    // Save updated cache manifest (skip if caller already saved it, e.g., dev mode template change)
     const endManifestSaveSpan = recorder.startSpan('cacheManifestSaveMs');
-    await saveCacheManifest(cacheDir, manifest);
+    if (!options.skipManifestSave) {
+        await saveCacheManifest(cacheDir, manifest);
+    }
     endManifestSaveSpan();
-    // Copy static assets and count them
+    // Copy static assets and count them (skip for template-only changes in dev mode)
     const endAssetSpan = recorder.startSpan('assetCopyMs');
     let assetsCount = 0;
-    assetsCount = await copyStaticAssets(config, outDir, logger);
+    if (!options.skipAssetCopy) {
+        assetsCount = await copyStaticAssets(config, outDir, logger);
+    }
     endAssetSpan();
     recorder.increment('assetsCopied', assetsCount);
     // Get current environment
@@ -616,8 +717,17 @@ async function buildInternal(options = {}) {
         await config.hooks.afterAll({ config, pages });
         endHookAfterAll();
     }
-    // Calculate build statistics
-    const buildStats = await generateBuildStats(pages, assetsCount, buildStartTime, outDir, cacheHits, cacheMisses, logger);
+    // Generate build statistics (skip in dev mode for performance)
+    const buildStats = isDevMode
+        ? {
+            totalPages: pages.length,
+            assetsCount: 0,
+            buildTimeMs: Date.now() - buildStartTime,
+            outputSizeBytes: 0,
+            cacheHits,
+            cacheMisses,
+        }
+        : await generateBuildStats(pages, assetsCount, buildStartTime, outDir, cacheHits, cacheMisses, logger, recorder);
     // Set ISG metrics
     const totalPages = pages.length;
     const cacheHitRate = totalPages > 0 ? cacheHits / totalPages : 0;

package/dist/core/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,mBAAmB,CAAC;AA6B7D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAwXD,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAoexF"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAkC7D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAobD,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAigBxF"}