@stati/core 1.1.0 → 1.2.0

package/README.md

@@ -107,18 +107,30 @@ const server = await createDevServer(config, {
 });
 ```
 
-#### `invalidate(options: InvalidateOptions): Promise<void>`
+#### `invalidate(query?: string): Promise<InvalidationResult>`
 
-Invalidate cache by tags or paths.
+Invalidate cache by tags, paths, patterns, or age.
 
 ```typescript
 import { invalidate } from '@stati/core';
 
-await invalidate({
-  tags: ['blog', 'posts'],
-  paths: ['/blog', '/about'],
-  config: './stati.config.js',
-});
+// Invalidate by tag
+await invalidate('tag:blog');
+
+// Invalidate by path prefix
+await invalidate('path:/posts');
+
+// Invalidate by glob pattern
+await invalidate('glob:/blog/**');
+
+// Invalidate content younger than 3 months
+await invalidate('age:3months');
+
+// Multiple criteria (OR logic)
+await invalidate('tag:blog age:1month');
+
+// Clear entire cache
+await invalidate();
 ```
 
 ### Configuration

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,aAAa,CAAC;AAqB/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CAkClF"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAsB/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CA2DlF"}

package/dist/config/loader.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'fs';
 import { join, resolve } from 'path';
 import { pathToFileURL } from 'url';
+import { validateISGConfig, ISGConfigurationError } from '../core/isg/validation.js';
 /**
  * Default configuration values for Stati.
  * Used as fallback when no configuration file is found.
@@ -59,15 +60,36 @@ export async function loadConfig(cwd = process.cwd()) {
         const configUrl = pathToFileURL(resolve(configPath)).href;
         const module = await import(configUrl);
         const userConfig = module.default || module;
-        return {
+        const mergedConfig = {
             ...DEFAULT_CONFIG,
             ...userConfig,
             site: { ...DEFAULT_CONFIG.site, ...userConfig.site },
             isg: { ...DEFAULT_CONFIG.isg, ...userConfig.isg },
         };
+        // Validate ISG configuration
+        try {
+            if (mergedConfig.isg) {
+                validateISGConfig(mergedConfig.isg);
+            }
+        }
+        catch (error) {
+            if (error instanceof ISGConfigurationError) {
+                throw new Error(`Invalid ISG configuration in ${configPath}:\n` +
+                    `${error.code}: ${error.message}\n` +
+                    `Field: ${error.field}, Value: ${JSON.stringify(error.value)}\n\n` +
+                    `Please check your stati.config.ts file and correct the ISG configuration.`);
+            }
+            throw error; // Re-throw non-ISG errors
+        }
+        return mergedConfig;
     }
     catch (error) {
-        console.error('Error loading config:', error);
+        if (error instanceof Error && error.message.includes('Invalid ISG configuration')) {
+            // ISG validation errors should bubble up with context
+            throw error;
+        }
+        console.error(`Error loading config from ${configPath}:`, error);
+        console.error('Falling back to default configuration.');
         return DEFAULT_CONFIG;
     }
 }

package/dist/core/build.d.ts

@@ -30,6 +30,7 @@ export interface BuildOptions {
 /**
  * Builds the static site by processing content files and generating HTML pages.
  * This is the main entry point for Stati's build process.
+ * Uses build locking to prevent concurrent builds from corrupting cache.
  *
  * @param options - Build configuration options
  *
@@ -51,6 +52,7 @@ export interface BuildOptions {
  * @throws {Error} When configuration loading fails
  * @throws {Error} When content processing fails
  * @throws {Error} When template rendering fails
+ * @throws {Error} When build lock cannot be acquired
  */
 export declare function build(options?: BuildOptions): Promise<BuildStats>;
 //# sourceMappingURL=build.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAgB,UAAU,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA2HD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAwI3E"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAgB,UAAU,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA2HD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAQ3E"}

package/dist/core/build.js

@@ -1,11 +1,15 @@
 import fse from 'fs-extra';
 const { ensureDir, writeFile, remove, pathExists, stat, readdir, copyFile } = fse;
-import { join, dirname } from 'path';
+import { join, dirname, relative } from 'path';
+import { posix } from 'path';
 import { loadConfig } from '../config/loader.js';
 import { loadContent } from './content.js';
 import { createMarkdownProcessor, renderMarkdown } from './markdown.js';
 import { createTemplateEngine, renderPage } from './templates.js';
 import { buildNavigation } from './navigation.js';
+import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
+import { shouldRebuildPage, createCacheEntry, updateCacheEntry } from './isg/builder.js';
+import { withBuildLock } from './isg/build-lock.js';
 /**
  * Recursively calculates the total size of a directory in bytes.
  * Used for build statistics.
@@ -50,7 +54,7 @@ async function copyStaticAssetsWithLogging(sourceDir, destDir, logger, basePath
     for (const item of items) {
         const sourcePath = join(sourceDir, item.name);
         const destPath = join(destDir, basePath, item.name);
-        const relativePath = join(basePath, item.name).replace(/\\/g, '/');
+        const relativePath = posix.normalize(posix.join(basePath, item.name));
         if (item.isDirectory()) {
             // Recursively copy directories
             await ensureDir(destPath);
@@ -92,17 +96,17 @@ const defaultLogger = {
 function formatBuildStats(stats) {
     const sizeKB = (stats.outputSizeBytes / 1024).toFixed(1);
     const timeSeconds = (stats.buildTimeMs / 1000).toFixed(2);
-    let output = `📊 Build Statistics:
+    let output = `Build Statistics:
 ┌─────────────────────────────────────────┐
-│  ⏱️  Build time: ${timeSeconds}s`.padEnd(41) + '│';
+│  Build time: ${timeSeconds}s`.padEnd(41) + '│';
     output += `\n│  📄 Pages built: ${stats.totalPages}`.padEnd(42) + '│';
     output += `\n│  📦 Assets copied: ${stats.assetsCount}`.padEnd(42) + '│';
-    output += `\n│  💾 Output size: ${sizeKB} KB`.padEnd(42) + '│';
+    output += `\n│  Output size: ${sizeKB} KB`.padEnd(42) + '│';
     if (stats.cacheHits !== undefined && stats.cacheMisses !== undefined) {
         const totalCacheRequests = stats.cacheHits + stats.cacheMisses;
         const hitRate = totalCacheRequests > 0 ? ((stats.cacheHits / totalCacheRequests) * 100).toFixed(1) : '0';
         output +=
-            `\n│  🎯 Cache hits: ${stats.cacheHits}/${totalCacheRequests} (${hitRate}%)`.padEnd(42) + '│';
+            `\n│  Cache hits: ${stats.cacheHits}/${totalCacheRequests} (${hitRate}%)`.padEnd(42) + '│';
     }
     output += '\n└─────────────────────────────────────────┘';
     return output;
@@ -110,6 +114,7 @@ function formatBuildStats(stats) {
 /**
  * Builds the static site by processing content files and generating HTML pages.
  * This is the main entry point for Stati's build process.
+ * Uses build locking to prevent concurrent builds from corrupting cache.
  *
  * @param options - Build configuration options
  *
@@ -131,8 +136,21 @@ function formatBuildStats(stats) {
  * @throws {Error} When configuration loading fails
  * @throws {Error} When content processing fails
  * @throws {Error} When template rendering fails
+ * @throws {Error} When build lock cannot be acquired
  */
 export async function build(options = {}) {
+    const cacheDir = join(process.cwd(), '.stati');
+    // Use build lock to prevent concurrent builds, with force option to override
+    return await withBuildLock(cacheDir, () => buildInternal(options), {
+        force: Boolean(options.force || options.clean), // Allow force if user explicitly requests it
+        timeout: 60000, // 1 minute timeout
+    });
+}
+/**
+ * Internal build implementation without locking.
+ * Separated for cleaner error handling and testing.
+ */
+async function buildInternal(options = {}) {
     const buildStartTime = Date.now();
     const logger = options.logger || defaultLogger;
     logger.building('Building your site...');
@@ -143,9 +161,22 @@ export async function build(options = {}) {
     // Create .stati cache directory
     const cacheDir = join(process.cwd(), '.stati');
     await ensureDir(cacheDir);
+    // Load cache manifest for ISG
+    let cacheManifest = await loadCacheManifest(cacheDir);
+    // If no cache manifest exists, create an empty one
+    if (!cacheManifest) {
+        cacheManifest = {
+            entries: {},
+        };
+    }
+    // At this point cacheManifest is guaranteed to be non-null
+    const manifest = cacheManifest;
+    // Initialize cache stats
+    let cacheHits = 0;
+    let cacheMisses = 0;
     // Clean output directory if requested
     if (options.clean) {
-        logger.info('🧹 Cleaning output directory...');
+        logger.info('Cleaning output directory...');
         await remove(outDir);
     }
     await ensureDir(outDir);
@@ -158,7 +189,7 @@ export async function build(options = {}) {
         logger.step(1, 3, 'Building navigation');
     }
     const navigation = buildNavigation(pages);
-    logger.info(`🧭 Built navigation with ${navigation.length} top-level items`);
+    logger.info(`Built navigation with ${navigation.length} top-level items`);
     // Display navigation tree if the logger supports it
     if (logger.navigationTree) {
         logger.navigationTree(navigation);
@@ -171,30 +202,28 @@ export async function build(options = {}) {
     if (config.hooks?.beforeAll) {
         await config.hooks.beforeAll(buildContext);
     }
-    // Render each page with progress tracking
+    // Render each page with tree-based progress tracking and ISG
     if (logger.step) {
         logger.step(2, 3, 'Rendering pages');
     }
+    // Initialize rendering tree
+    if (logger.startRenderingTree) {
+        logger.startRenderingTree('Page Rendering Process');
+    }
+    const buildTime = new Date();
     for (let i = 0; i < pages.length; i++) {
         const page = pages[i];
         if (!page)
             continue; // Safety check
-        // Show progress for page rendering
-        if (logger.progress) {
-            logger.progress(i + 1, pages.length, `Rendering ${page.url}`);
+        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(`Building ${page.url}`);
+            logger.processing(`Checking ${page.url}`);
         }
-        // Run beforeRender hook
-        if (config.hooks?.beforeRender) {
-            await config.hooks.beforeRender({ page, config });
-        }
-        // Render markdown to HTML
-        const htmlContent = renderMarkdown(page.content, md);
-        // Render with template
-        const finalHtml = await renderPage(page, htmlContent, config, eta, navigation, pages);
-        // Determine output path - fix the logic here
+        // Determine output path
         let outputPath;
         if (page.url === '/') {
             outputPath = join(outDir, 'index.html');
@@ -205,14 +234,78 @@ export async function build(options = {}) {
         else {
             outputPath = join(outDir, `${page.url}.html`);
         }
+        // Get cache key (use output path relative to outDir)
+        const relativePath = relative(outDir, outputPath).replace(/\\/g, '/');
+        const cacheKey = relativePath.startsWith('/') ? relativePath : `/${relativePath}`;
+        const existingEntry = manifest.entries[cacheKey];
+        // Check if we should rebuild this page (considering ISG logic)
+        const shouldRebuild = options.force || (await shouldRebuildPage(page, existingEntry, config, buildTime));
+        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}`);
+            }
+            continue;
+        }
+        // Cache miss - need to rebuild
+        cacheMisses++;
+        const startTime = Date.now();
+        // Add rendering substeps to tree
+        const markdownId = `${pageId}-markdown`;
+        const templateId = `${pageId}-template`;
+        if (logger.addTreeNode) {
+            logger.addTreeNode(pageId, markdownId, 'Processing Markdown', 'running');
+            logger.addTreeNode(pageId, templateId, 'Applying Template', 'pending');
+        }
+        // Run beforeRender hook
+        if (config.hooks?.beforeRender) {
+            await config.hooks.beforeRender({ page, config });
+        }
+        // Render markdown to HTML
+        const htmlContent = renderMarkdown(page.content, md);
+        if (logger.updateTreeNode) {
+            logger.updateTreeNode(markdownId, 'completed');
+            logger.updateTreeNode(templateId, 'running');
+        }
+        // Render with template
+        const finalHtml = await renderPage(page, htmlContent, config, eta, navigation, pages);
+        const renderTime = Date.now() - startTime;
+        if (logger.updateTreeNode) {
+            logger.updateTreeNode(templateId, 'completed');
+            logger.updateTreeNode(pageId, 'completed', {
+                timing: renderTime,
+                url: page.url,
+            });
+        }
         // 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);
+        }
+        else {
+            manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime);
+        }
         // Run afterRender hook
         if (config.hooks?.afterRender) {
             await config.hooks.afterRender({ page, config });
         }
     }
+    // Display final rendering tree and clear it
+    if (logger.showRenderingTree) {
+        console.log(); // Add spacing
+        logger.showRenderingTree();
+        if (logger.clearRenderingTree) {
+            logger.clearRenderingTree();
+        }
+    }
+    // Save updated cache manifest
+    await saveCacheManifest(cacheDir, manifest);
     // Copy static assets and count them
     let assetsCount = 0;
     const staticDir = join(process.cwd(), config.staticDir);
@@ -221,9 +314,9 @@ export async function build(options = {}) {
         if (logger.step) {
             logger.step(3, 3, 'Copying static assets');
         }
-        logger.info(`📦 Copying static assets from ${config.staticDir}`);
+        logger.info(`Copying static assets from ${config.staticDir}`);
         assetsCount = await copyStaticAssetsWithLogging(staticDir, outDir, logger);
-        logger.info(`📦 Copied ${assetsCount} static assets`);
+        logger.info(`Copied ${assetsCount} static assets`);
     }
     // Run afterAll hook
     if (config.hooks?.afterAll) {
@@ -236,9 +329,9 @@ export async function build(options = {}) {
         assetsCount,
         buildTimeMs: buildEndTime - buildStartTime,
         outputSizeBytes: await getDirectorySize(outDir),
-        // Cache stats would be populated here when caching is implemented
-        cacheHits: 0,
-        cacheMisses: 0,
+        // Include ISG cache statistics
+        cacheHits,
+        cacheMisses,
     };
     console.log(); // Add spacing before statistics
     // Use table format if available, otherwise fall back to formatted string

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

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,aAAa,CAAC;AAKvD,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;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAgVxF"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,aAAa,CAAC;AAMvD,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;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CA0ZxF"}

package/dist/core/dev.js

@@ -1,10 +1,12 @@
 import { createServer } from 'http';
 import { join, extname } from 'path';
+import { posix } from 'path';
 import { readFile, stat } from 'fs/promises';
 import { WebSocketServer } from 'ws';
 import chokidar from 'chokidar';
 import { build } from './build.js';
 import { loadConfig } from '../config/loader.js';
+import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
 /**
  * Creates and configures a development server with live reload functionality.
  *
@@ -47,7 +49,6 @@ export async function createDevServer(options = {}) {
      * Performs an initial build to ensure dist/ exists
      */
     async function initialBuild() {
-        logger.info?.('🏗️  Performing initial build...');
         try {
             await build({
                 logger,
@@ -55,7 +56,6 @@ export async function createDevServer(options = {}) {
                 clean: false,
                 ...(configPath && { configPath }),
             });
-            logger.success?.('✅ Initial build complete');
         }
         catch (error) {
             logger.error?.(`Initial build failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -63,7 +63,7 @@ export async function createDevServer(options = {}) {
         }
     }
     /**
-     * Performs incremental rebuild when files change
+     * Performs incremental rebuild when files change, using ISG logic for smart rebuilds
      */
     async function incrementalRebuild(changedPath) {
         if (isBuilding) {
@@ -71,14 +71,22 @@ export async function createDevServer(options = {}) {
             return;
         }
         isBuilding = true;
-        logger.info?.(`🔄 Rebuilding due to change: ${changedPath}`);
         try {
-            await build({
-                logger,
-                force: false,
-                clean: false,
-                ...(configPath && { configPath }),
-            });
+            // Check if the changed file is a template/partial
+            if (changedPath.endsWith('.eta') || changedPath.includes('_partials')) {
+                logger.info?.(`🎨 Template changed: ${changedPath}`);
+                await handleTemplateChange(changedPath);
+            }
+            else {
+                // Content or static file changed - use normal rebuild
+                logger.info?.(`📄 Content changed: ${changedPath}`);
+                await build({
+                    logger,
+                    force: false,
+                    clean: false,
+                    ...(configPath && { configPath }),
+                });
+            }
             // Notify all connected clients to reload
             if (wsServer) {
                 wsServer.clients.forEach((client) => {
@@ -89,7 +97,7 @@ export async function createDevServer(options = {}) {
                     }
                 });
             }
-            logger.success?.('✅ Rebuild complete');
+            logger.success?.('Rebuild complete');
         }
         catch (error) {
             logger.error?.(`Rebuild failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -98,6 +106,62 @@ export async function createDevServer(options = {}) {
             isBuilding = false;
         }
     }
+    /**
+     * Handles template/partial file changes by invalidating affected pages
+     */
+    async function handleTemplateChange(templatePath) {
+        const cacheDir = join(process.cwd(), '.stati');
+        try {
+            // Load existing cache manifest
+            let cacheManifest = await loadCacheManifest(cacheDir);
+            if (!cacheManifest) {
+                // No cache exists, perform full rebuild
+                logger.info?.('No cache found, performing full rebuild...');
+                await build({
+                    logger,
+                    force: false,
+                    clean: false,
+                    ...(configPath && { configPath }),
+                });
+                return;
+            }
+            // Find pages that depend on this template
+            const affectedPages = [];
+            for (const [pagePath, entry] of Object.entries(cacheManifest.entries)) {
+                if (entry.deps.some((dep) => dep.includes(posix.normalize(templatePath.replace(/\\/g, '/'))))) {
+                    affectedPages.push(pagePath);
+                    // Remove from cache to force rebuild
+                    delete cacheManifest.entries[pagePath];
+                }
+            }
+            if (affectedPages.length > 0) {
+                logger.info?.(`🎯 Invalidating ${affectedPages.length} affected pages:`);
+                affectedPages.forEach((page) => logger.info?.(`   📄 ${page}`));
+                // Save updated cache manifest
+                await saveCacheManifest(cacheDir, cacheManifest);
+                // Perform incremental rebuild (only affected pages will be rebuilt)
+                await build({
+                    logger,
+                    force: false,
+                    clean: false,
+                    ...(configPath && { configPath }),
+                });
+            }
+            else {
+                logger.info?.('ℹ️  No pages affected by template change');
+            }
+        }
+        catch (error) {
+            logger.warning?.(`Template dependency analysis failed, performing full rebuild: ${error instanceof Error ? error.message : String(error)}`);
+            // Fallback to full rebuild
+            await build({
+                logger,
+                force: false,
+                clean: false,
+                ...(configPath && { configPath }),
+            });
+        }
+    }
     /**
      * Gets MIME type for a file based on its extension
      */
@@ -133,15 +197,15 @@ export async function createDevServer(options = {}) {
   ws.onmessage = function(event) {
     const data = JSON.parse(event.data);
     if (data.type === 'reload') {
-      console.log('🔄 Reloading page due to file changes...');
+      console.log('Reloading page due to file changes...');
       window.location.reload();
     }
   };
   ws.onopen = function() {
-    console.log('🔗 Connected to Stati dev server');
+    console.log('Connected to Stati dev server');
   };
   ws.onclose = function() {
-    console.log('❌ Lost connection to Stati dev server');
+    console.log('Lost connection to Stati dev server');
     // Try to reconnect after a delay
     setTimeout(() => window.location.reload(), 1000);
   };
@@ -241,7 +305,7 @@ export async function createDevServer(options = {}) {
                 logger.info?.('🔗 Browser connected for live reload');
                 const websocket = ws;
                 websocket.on('close', () => {
-                    logger.info?.('❌ Browser disconnected from live reload');
+                    logger.info?.('Browser disconnected from live reload');
                 });
             });
             // Start HTTP server
@@ -269,9 +333,11 @@ export async function createDevServer(options = {}) {
             watcher.on('unlink', (path) => {
                 void incrementalRebuild(path);
             });
-            logger.success?.(`🚀 Dev server running at ${url}`);
-            logger.info?.(`📁 Serving from: ${outDir}`);
-            logger.info?.(`👀 Watching: ${watchPaths.join(', ')}`);
+            logger.success?.(`Dev server running at ${url}`);
+            logger.info?.(`\nServing from:`);
+            logger.info?.(`  📁 ${outDir}`);
+            logger.info?.('Watching:');
+            watchPaths.forEach((path) => logger.info?.(`  📁 ${path}`));
             // Open browser if requested
             if (open) {
                 try {

package/dist/core/invalidate.d.ts

@@ -1,2 +1,68 @@
-export declare function invalidate(query?: string): Promise<void>;
+import type { CacheEntry } from '../types.js';
+/**
+ * Invalidation result containing affected cache entries.
+ */
+export interface InvalidationResult {
+    /** Number of cache entries invalidated */
+    invalidatedCount: number;
+    /** Paths of invalidated pages */
+    invalidatedPaths: string[];
+    /** Whether the entire cache was cleared */
+    clearedAll: boolean;
+}
+/**
+ * Parses an invalidation query string into individual query terms.
+ * Supports space-separated values and quoted strings.
+ *
+ * @param query - The query string to parse
+ * @returns Array of parsed query terms
+ *
+ * @example
+ * ```typescript
+ * parseInvalidationQuery('tag:blog path:/posts') // ['tag:blog', 'path:/posts']
+ * parseInvalidationQuery('"tag:my tag" path:"/my path"') // ['tag:my tag', 'path:/my path']
+ * ```
+ */
+export declare function parseInvalidationQuery(query: string): string[];
+/**
+ * Checks if a cache entry matches a specific invalidation term.
+ *
+ * @param entry - Cache entry to check
+ * @param path - The page path for this entry
+ * @param term - Invalidation term to match against
+ * @returns True if the entry matches the term
+ *
+ * @example
+ * ```typescript
+ * matchesInvalidationTerm(entry, '/blog/post-1', 'tag:blog') // true if entry has 'blog' tag
+ * matchesInvalidationTerm(entry, '/blog/post-1', 'path:/blog') // true (path prefix match)
+ * ```
+ */
+export declare function matchesInvalidationTerm(entry: CacheEntry, path: string, term: string): boolean;
+/**
+ * Invalidates cache entries based on a query string.
+ * Supports tag-based, path-based, pattern-based, and time-based invalidation.
+ *
+ * @param query - Invalidation query string, or undefined to clear all cache
+ * @returns Promise resolving to invalidation result
+ *
+ * @example
+ * ```typescript
+ * // Invalidate all pages with 'blog' tag
+ * await invalidate('tag:blog');
+ *
+ * // Invalidate specific path
+ * await invalidate('path:/about');
+ *
+ * // Invalidate content younger than 3 months
+ * await invalidate('age:3months');
+ *
+ * // Invalidate multiple criteria
+ * await invalidate('tag:blog age:1week');
+ *
+ * // Clear entire cache
+ * await invalidate();
+ * ```
+ */
+export declare function invalidate(query?: string): Promise<InvalidationResult>;
 //# sourceMappingURL=invalidate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AAAA,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9D"}
+{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAkC9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAkC9F;AAiLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoD5E"}