@stati/core 1.20.3 → 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":"AAsDA,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;AA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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, } 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';
 /**
@@ -50,8 +50,9 @@ async function getDirectorySize(dirPath) {
  */
 async function copyStaticAssetsWithLogging(sourceDir, destDir, logger, basePath = '') {
     let filesCopied = 0;
+    let totalBytes = 0;
     if (!(await pathExists(sourceDir))) {
-        return 0;
+        return { count: 0, totalBytes: 0 };
     }
     const items = await readdir(sourceDir, { withFileTypes: true });
     for (const item of items) {
@@ -61,22 +62,26 @@ async function copyStaticAssetsWithLogging(sourceDir, destDir, logger, basePath
         if (item.isDirectory()) {
             // Recursively copy directories
             await ensureDir(destPath);
-            filesCopied += await copyStaticAssetsWithLogging(sourcePath, destPath, logger);
+            const result = await copyStaticAssetsWithLogging(sourcePath, destPath, logger);
+            filesCopied += result.count;
+            totalBytes += result.totalBytes;
         }
         else {
             // Copy individual files
             await ensureDir(dirname(destPath));
             await copyFile(sourcePath, destPath);
+            const fileStats = await stat(sourcePath);
             if (logger.file) {
-                logger.file('copy', relativePath);
+                logger.file('copy', relativePath, fileStats.size);
             }
             else {
-                logger.processing(`📄 ${relativePath}`);
+                logger.processing(`• ${relativePath}`);
             }
             filesCopied++;
+            totalBytes += fileStats.size;
         }
     }
-    return filesCopied;
+    return { count: filesCopied, totalBytes };
 }
 /**
  * Default console logger implementation.
@@ -86,6 +91,7 @@ const defaultLogger = {
     success: (message) => console.log(message),
     warning: (message) => console.warn(message),
     error: (message) => console.error(message),
+    status: (message) => console.log(message),
     building: (message) => console.log(message),
     processing: (message) => console.log(message),
     stats: (message) => console.log(message),
@@ -127,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
     });
@@ -169,7 +184,7 @@ async function setupCacheAndManifest(cacheDir) {
 async function loadContentAndBuildNavigation(config, options, logger) {
     // Load all content
     const pages = await loadContent(config, options.includeDrafts);
-    logger.info(`📄 Found ${pages.length} pages`);
+    logger.status(`Found ${pages.length} pages`);
     // Build navigation from pages
     if (logger.step) {
         console.log(); // Add spacing before navigation step
@@ -203,26 +218,28 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
         await config.hooks.beforeAll(buildContext);
         endHookBeforeAll();
     }
-    // Render each page with tree-based progress tracking and ISG
+    // Render each page with progress tracking and ISG
     if (logger.step) {
         logger.step(2, 3, 'Rendering pages');
+        console.log(); // Add spacing after step header
     }
-    // Initialize rendering tree
-    if (logger.startRenderingTree) {
-        logger.startRenderingTree('Page Rendering Process');
+    // Initialize progress tracking
+    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)
             continue; // Safety check
-        const pageId = `page-${i}`;
-        // Add page to rendering tree
-        if (logger.addTreeNode) {
-            logger.addTreeNode('root', pageId, page.url, 'running', { url: page.url });
-        }
-        else {
-            logger.processing(`Checking ${page.url}`);
-        }
         // Determine output path
         let outputPath;
         if (page.url === '/') {
@@ -239,15 +256,15 @@ 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++;
-            if (logger.updateTreeNode) {
-                logger.updateTreeNode(pageId, 'cached', { cacheHit: true, url: page.url });
-            }
-            else {
-                logger.processing(`📋 Cached ${page.url}`);
+            if (logger.updateProgress) {
+                logger.updateProgress('cached', page.url);
             }
             // Record page timing for cached pages (0ms render time)
             recorder.recordPageTiming(page.url, 0, true);
@@ -283,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);
@@ -313,21 +333,31 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
         const renderTime = Math.round(performance.now() - startTime);
         // Record page timing for rendered pages (includes template count)
         recorder.recordPageTiming(page.url, renderTime, false, renderResult.templatesLoaded);
-        if (logger.updateTreeNode) {
-            logger.updateTreeNode(pageId, 'completed', {
-                timing: renderTime,
-                url: page.url,
-            });
+        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
@@ -341,11 +371,41 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
             recorder.addToPhase('hookAfterRenderTotalMs', performance.now() - hookStart);
         }
     }
-    // Display final rendering tree and clear it
-    if (logger.showRenderingTree) {
-        logger.showRenderingTree();
-        if (logger.clearRenderingTree) {
-            logger.clearRenderingTree();
+    // 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();
+        if (logger.showRenderingSummary) {
+            logger.showRenderingSummary();
         }
     }
     return { cacheHits, cacheMisses, searchablePages };
@@ -363,20 +423,30 @@ async function copyStaticAssets(config, outDir, logger) {
         logger.step(3, 3, 'Copying static assets');
     }
     logger.info(`Copying static assets from ${config.staticDir}`);
-    const assetsCount = await copyStaticAssetsWithLogging(staticDir, outDir, logger);
-    logger.info(`Copied ${assetsCount} static assets`);
+    const { count: assetsCount, totalBytes } = await copyStaticAssetsWithLogging(staticDir, outDir, logger);
+    if (assetsCount > 0) {
+        const totalSizeStr = formatBytes(totalBytes);
+        logger.success(`Copied ${assetsCount} static assets (${totalSizeStr})`);
+    }
+    else {
+        logger.info(`Copied 0 static assets`);
+    }
     return assetsCount;
 }
 /**
  * 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,
@@ -412,7 +482,7 @@ async function buildInternal(options = {}) {
         cliVersion: options.cliVersion,
         coreVersion: options.coreVersion,
     });
-    logger.building('Building your site...');
+    logger.status('Started building your site...');
     // Load configuration (instrumented)
     const endConfigSpan = recorder.startSpan('configLoadMs');
     const { config, outDir, cacheDir } = await loadAndValidateConfig(options);
@@ -422,12 +492,13 @@ async function buildInternal(options = {}) {
     let cacheMisses = 0;
     // Clean output directory and cache if requested
     if (options.clean) {
-        logger.info('Cleaning output directory and ISG cache...');
+        logger.status('Cleaning output directory and ISG cache...');
         await remove(outDir);
         await remove(cacheDir);
     }
     await ensureDir(outDir);
     // Enable Tailwind class inventory tracking only if Tailwind is detected
+    const tailwindInitStart = performance.now();
     const hasTailwind = await isTailwindUsed();
     if (hasTailwind) {
         enableInventoryTracking();
@@ -438,16 +509,18 @@ async function buildInternal(options = {}) {
             // Write the initial inventory file immediately so Tailwind can scan it
             // This is critical for dev server where Tailwind starts watching before template rendering
             await writeTailwindClassInventory(cacheDir);
-            logger.info(`📦 Loaded ${loadedCount} classes from previous build for Tailwind scanner`);
+            logger.status(`Loaded ${loadedCount} classes from previous build for Tailwind scanner`);
         }
         else {
             // No previous inventory found - write an empty placeholder file
             // This ensures Tailwind has a file to scan even on first build
             // It will be populated with actual classes after template rendering
             await writeTailwindClassInventory(cacheDir);
-            logger.info(`📦 Created inventory file for Tailwind scanner (will be populated after rendering)`);
+            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);
@@ -467,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) {
@@ -503,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.info(`📝 Generated Tailwind class inventory (${inventorySize} classes tracked)`);
+            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
@@ -551,7 +651,7 @@ async function buildInternal(options = {}) {
             logger.success(`Generated sitemap index with ${sitemapResult.sitemaps.length} sitemaps (${sitemapResult.entryCount} entries)`);
         }
         else {
-            logger.success(`Generated sitemap with ${sitemapResult.entryCount} entries`);
+            logger.success(`Generated sitemap.xml with ${sitemapResult.entryCount} entries (${(sitemapResult.sizeInBytes / 1024).toFixed(2)} KB)`);
         }
     }
     // Generate robots.txt if enabled (only in production mode)
@@ -562,7 +662,8 @@ async function buildInternal(options = {}) {
         logger.info('Generating robots.txt...');
         const robotsContent = generateRobotsTxtFromConfig(config.robots, config.site.baseUrl);
         await writeFile(join(outDir, 'robots.txt'), robotsContent);
-        logger.success('Generated robots.txt');
+        const robotsSizeBytes = Buffer.byteLength(robotsContent, 'utf8');
+        logger.success(`Generated robots.txt (${robotsSizeBytes} bytes)`);
     }
     // Generate RSS feeds if enabled (only in production mode)
     if (config.rss?.enabled && currentEnv === 'production') {
@@ -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;AAuXD,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAgexF"}
+{"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"}