@stati/core 1.20.3 → 1.22.0

package/dist/core/dev.js

@@ -6,7 +6,7 @@ import chokidar from 'chokidar';
 import { build } from './build.js';
 import { invalidate } from './invalidate.js';
 import { loadConfig } from '../config/loader.js';
-import { loadCacheManifest, saveCacheManifest, computeNavigationHash } from './isg/index.js';
+import { loadCacheManifest, saveCacheManifest, computeNavigationHash, DevServerLockManager, } from './isg/index.js';
 import { loadContent } from './content.js';
 import { buildNavigation } from './navigation.js';
 import { resolveDevPaths, resolveCacheDir, resolvePrettyUrl, createErrorOverlay, parseErrorDetails, TemplateError, createFallbackLogger, mergeServerOptions, createTypeScriptWatcher, normalizePathForComparison, isPathWithinDirectory, } from './utils/index.js';
@@ -38,7 +38,7 @@ async function loadDevConfig(configPath, logger) {
 async function performInitialBuild(configPath, logger, onError) {
     try {
         // Clear cache to ensure fresh build on dev server start
-        logger.info?.('Clearing cache for fresh development build...');
+        logger.status('Clearing cache for fresh development build...');
         await invalidate();
         await build({
             logger,
@@ -87,15 +87,29 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
     const startTime = Date.now();
     // All changes being processed in this build (primary + batched)
     const allChanges = [{ path: changedPath, eventType }, ...batchedChanges];
-    // Create a quiet logger for dev builds that suppresses verbose output
-    const devLogger = {
-        info: () => { }, // Suppress info messages
-        success: () => { }, // Suppress success messages
-        error: logger.error || (() => { }),
-        warning: logger.warning || (() => { }),
-        building: () => { }, // Suppress building messages
-        processing: () => { }, // Suppress processing messages
-        stats: () => { }, // Suppress stats messages
+    // Create a dev logger that shows progress for template rebuilds
+    // but suppresses other verbose output
+    const createDevLogger = (showProgress) => {
+        const baseLogger = {
+            info: () => { }, // Suppress info messages
+            success: () => { }, // Suppress success messages
+            error: logger.error || (() => { }),
+            warning: logger.warning || (() => { }),
+            status: () => { }, // Suppress status messages
+            building: () => { }, // Suppress building messages
+            processing: () => { }, // Suppress processing messages
+            stats: () => { }, // Suppress stats messages
+        };
+        // Enable progress tracking for template rebuilds (but not the full summary)
+        if (showProgress && logger.startProgress && logger.updateProgress && logger.endProgress) {
+            return {
+                ...baseLogger,
+                startProgress: logger.startProgress,
+                updateProgress: logger.updateProgress,
+                endProgress: logger.endProgress,
+            };
+        }
+        return baseLogger;
     };
     // Helper to check if a path is a static asset
     const normalizedStaticDir = staticDir.replace(/\\/g, '/');
@@ -105,16 +119,22 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
     };
     // Helper to get relative path
     const getRelativePath = (path) => path.replace(process.cwd(), '').replace(/\\/g, '/').replace(/^\//, '');
+    // Track template change result for better output
+    let templateChangeResult = null;
     try {
         // Check if the changed file is a template/partial
         if (changedPath.endsWith(TEMPLATE_EXTENSION) || changedPath.includes('_partials')) {
-            await handleTemplateChange(changedPath, configPath, devLogger);
+            // Use progress-enabled logger for template changes (rebuilds multiple pages)
+            const devLogger = createDevLogger(true);
+            templateChangeResult = await handleTemplateChange(changedPath, configPath, devLogger);
         }
         else if (changedPath.endsWith('.md')) {
+            const devLogger = createDevLogger(false);
             await handleMarkdownChange(changedPath, configPath, devLogger);
         }
         else {
             // Static file changed - use normal rebuild
+            const devLogger = createDevLogger(false);
             await build({
                 logger: devLogger,
                 force: false,
@@ -137,7 +157,7 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
             });
         }
         const duration = Date.now() - startTime;
-        // Log all files that were processed in this batch
+        // Log rebuild result with affected page info for template changes
         for (const change of allChanges) {
             const relativePath = getRelativePath(change.path);
             let action;
@@ -150,14 +170,22 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
             else {
                 action = 'rebuilt';
             }
-            logger.info?.(`⚡ ${relativePath} ${action}`);
+            // For template changes, include affected page count
+            if (templateChangeResult && templateChangeResult.affectedPages > 0) {
+                const { affectedPages, totalPages } = templateChangeResult;
+                logger.info?.(`▸ ${relativePath} ${action}`);
+                logger.info?.(`   ${affectedPages}/${totalPages} pages rebuilt in ${duration}ms`);
+            }
+            else {
+                logger.info?.(`▸ ${relativePath} ${action}`);
+                logger.info?.(`   Done in ${duration}ms`);
+            }
         }
-        logger.info?.(`   Done in ${duration}ms`);
     }
     catch (error) {
         const buildError = error instanceof Error ? error : new Error(String(error));
         const duration = Date.now() - startTime;
-        logger.error?.(`❌ Rebuild failed after ${duration}ms: ${buildError.message}`);
+        logger.error?.(`× Rebuild failed after ${duration}ms: ${buildError.message}`);
         // Store the error for display in browser
         if (onError) {
             onError(buildError);
@@ -183,6 +211,8 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
  * Handles template/partial file changes by invalidating affected pages.
  * Uses proper path normalization to ensure reliable matching between
  * file watcher paths and cached dependency paths.
+ *
+ * @returns Object with affected and total page counts
  */
 async function handleTemplateChange(templatePath, configPath, logger) {
     const cacheDir = resolveCacheDir();
@@ -197,38 +227,50 @@ async function handleTemplateChange(templatePath, configPath, logger) {
                 clean: false,
                 ...(configPath && { configPath }),
             });
-            return;
+            return { affectedPages: 0, totalPages: 0 };
         }
         // Normalize the changed template path to absolute POSIX format for reliable comparison
         // This handles cases where the watcher provides relative paths, Windows paths, or different
         // path representations than what's stored in the cache manifest
+        // NOTE: Only used for string comparison, never for file system operations
         const normalizedTemplatePath = normalizePathForComparison(templatePath);
+        // Get total page count from manifest
+        const totalPages = Object.keys(cacheManifest.entries).length;
         // Find pages that depend on this template
         let affectedPagesCount = 0;
         for (const [pagePath, entry] of Object.entries(cacheManifest.entries)) {
             // Check if any of the page's dependencies match the changed template
             const hasMatchingDep = entry.deps.some((dep) => {
-                // Normalize the cached dependency path to the same format
+                // Normalize the cached dependency path to the same format for comparison only
                 const normalizedDep = normalizePathForComparison(dep);
                 // Direct path comparison - both paths are now in consistent format
                 return normalizedDep === normalizedTemplatePath;
             });
             if (hasMatchingDep) {
                 affectedPagesCount++;
-                // Remove from cache to force rebuild
-                delete cacheManifest.entries[pagePath];
+                // Mark entry as stale by invalidating its inputsHash
+                // This forces a rebuild while preserving deps for fast update optimization
+                cacheManifest.entries[pagePath] = {
+                    ...entry,
+                    inputsHash: 'STALE', // Forces rebuild in shouldRebuildPage
+                };
             }
         }
         if (affectedPagesCount > 0) {
             // Save updated cache manifest
             await saveCacheManifest(cacheDir, cacheManifest);
             // Perform incremental rebuild (only affected pages will be rebuilt)
+            // skipManifestSave: true because we already saved the manifest above
+            // skipAssetCopy: true because template changes don't affect static assets
             await build({
                 logger,
                 force: false,
                 clean: false,
+                skipManifestSave: true,
+                skipAssetCopy: true,
                 ...(configPath && { configPath }),
             });
+            return { affectedPages: affectedPagesCount, totalPages };
         }
         else {
             // If no affected pages were found but a template changed,
@@ -240,6 +282,7 @@ async function handleTemplateChange(templatePath, configPath, logger) {
                 clean: false,
                 ...(configPath && { configPath }),
             });
+            return { affectedPages: totalPages, totalPages };
         }
     }
     catch (_error) {
@@ -255,6 +298,8 @@ async function handleTemplateChange(templatePath, configPath, logger) {
         catch (fallbackError) {
             throw fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError));
         }
+        // Return zeros on error fallback
+        return { affectedPages: 0, totalPages: 0 };
     }
 }
 /**
@@ -286,7 +331,7 @@ async function handleMarkdownChange(_markdownPath, configPath, logger) {
         // Compare navigation hashes
         if (newNavigationHash !== cacheManifest.navigationHash) {
             // Navigation structure changed - clear cache and force full rebuild
-            logger.info?.('📊 Navigation structure changed, performing full rebuild...');
+            logger.status('Navigation structure changed, performing full rebuild...');
             // Force rebuild bypasses ISG cache entirely
             await build({
                 logger,
@@ -336,6 +381,9 @@ export async function createDevServer(options = {}) {
         },
     });
     setEnv('development');
+    // Create dev server lock manager
+    const cacheDir = resolveCacheDir();
+    const devLock = new DevServerLockManager(cacheDir);
     const url = `http://${host}:${port}`;
     let httpServer = null;
     let wsServer = null;
@@ -386,7 +434,7 @@ 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();
     }
   };
@@ -531,18 +579,40 @@ export async function createDevServer(options = {}) {
     const devServer = {
         url,
         async start() {
+            // Acquire dev server lock to prevent multiple dev servers in the same directory
+            try {
+                await devLock.acquireLock();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.error?.(`Failed to start dev server:\n${message}`);
+                throw error;
+            }
             // Perform initial build
             await performInitialBuild(configPath, logger, setLastBuildError);
             // Create HTTP server
             httpServer = createServer(async (req, res) => {
                 const requestPath = req.url || '/';
+                const requestStart = Date.now();
                 // Handle WebSocket upgrade path
                 if (requestPath === '/__ws') {
                     return; // Let WebSocket server handle this
                 }
-                logger.processing?.(`${req.method} ${requestPath}`);
+                // Only log page requests, not static assets (files with extensions)
+                const hasFileExtension = requestPath.includes('.') && !requestPath.endsWith('.html');
+                if (!hasFileExtension) {
+                    logger.processing?.(`${req.method} ${requestPath}`);
+                }
                 try {
                     const { content, mimeType, statusCode } = await serveFile(requestPath);
+                    const responseTime = Date.now() - requestStart;
+                    // Log slow responses with memory info
+                    if (responseTime > 2000) {
+                        const mem = process.memoryUsage();
+                        const heapMB = Math.round(mem.heapUsed / 1024 / 1024);
+                        const rssMB = Math.round(mem.rss / 1024 / 1024);
+                        logger.warning?.(`Slow response: ${requestPath} took ${responseTime}ms (heap: ${heapMB}MB, rss: ${rssMB}MB)`);
+                    }
                     res.writeHead(statusCode, {
                         'Content-Type': mimeType,
                         'Access-Control-Allow-Origin': '*',
@@ -595,7 +665,7 @@ export async function createDevServer(options = {}) {
                         outDir: config.outDir || DEFAULT_OUT_DIR,
                         logger,
                         onRebuild: (_results, compileTimeMs) => {
-                            logger.info?.(`⚡ TypeScript recompiled in ${compileTimeMs}ms`);
+                            logger.info?.(`▸ TypeScript recompiled in ${compileTimeMs}ms`);
                             // Broadcast reload to WebSocket clients
                             if (wsServer) {
                                 wsServer.clients.forEach((client) => {
@@ -615,7 +685,7 @@ export async function createDevServer(options = {}) {
                     console.log();
                     logger.error?.(`TypeScript setup failed: ${tsError.message}`);
                     logger.warning?.('──────────────────────────────────────────────────────────────');
-                    logger.warning?.('⚠️  TypeScript hot reload is DISABLED for this session.');
+                    logger.warning?.('!  TypeScript hot reload is DISABLED for this session.');
                     logger.warning?.("    Dev server will continue, but TypeScript changes won't auto-reload.");
                     logger.warning?.('    Fix your TypeScript configuration and restart the dev server.');
                     logger.warning?.('──────────────────────────────────────────────────────────────');
@@ -638,7 +708,7 @@ export async function createDevServer(options = {}) {
             });
             cssWatcher.on('change', (path) => {
                 const relativePath = path.replace(process.cwd(), '').replace(/\\/g, '/').replace(/^\//, '');
-                logger.info?.(`⚡ ${relativePath} updated`);
+                logger.info?.(`▸ ${relativePath} updated`);
                 // Just notify clients to reload - no rebuild needed since CSS was already compiled
                 if (wsServer) {
                     wsServer.clients.forEach((client) => {
@@ -660,9 +730,9 @@ export async function createDevServer(options = {}) {
             });
             logger.success?.(`Dev server running at ${url}`);
             logger.info?.(`\nServing:`);
-            logger.info?.(`  📁 ${outDir}`);
+            logger.info?.(`  • ${outDir}`);
             logger.info?.('Watching:');
-            watchPaths.forEach((path) => logger.info?.(`  📁 ${path}`));
+            watchPaths.forEach((path) => logger.info?.(`  • ${path}`));
             logger.info?.('');
             // Open browser if requested
             if (open) {
@@ -679,6 +749,8 @@ export async function createDevServer(options = {}) {
             if (isStopping)
                 return;
             isStopping = true;
+            // Release dev server lock first to allow other servers to start
+            await devLock.releaseLock();
             if (watcher) {
                 await watcher.close();
                 watcher = null;

package/dist/core/isg/builder.d.ts

@@ -35,11 +35,14 @@ export declare function shouldRebuildPage(page: PageModel, entry: CacheEntry | u
 export declare function createCacheEntry(page: PageModel, config: StatiConfig, renderedAt: Date): Promise<CacheEntry>;
 /**
  * Updates an existing cache entry with new information after rebuilding.
+ * In dev mode, this is optimized to reuse the existing deps array since
+ * template structure rarely changes between incremental rebuilds.
  *
  * @param entry - Existing cache entry
  * @param page - The page model
  * @param config - Stati configuration
  * @param renderedAt - When the page was rendered
+ * @param fastUpdate - If true, skip expensive dep tracking (dev mode optimization)
  * @returns Updated cache entry
  *
  * @example
@@ -47,5 +50,5 @@ export declare function createCacheEntry(page: PageModel, config: StatiConfig, r
  * const updatedEntry = await updateCacheEntry(existingEntry, page, config, new Date());
  * ```
  */
-export declare function updateCacheEntry(entry: CacheEntry, page: PageModel, config: StatiConfig, renderedAt: Date): Promise<CacheEntry>;
+export declare function updateCacheEntry(entry: CacheEntry, page: PageModel, config: StatiConfig, renderedAt: Date, fastUpdate?: boolean): Promise<CacheEntry>;
 //# sourceMappingURL=builder.d.ts.map

package/dist/core/isg/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/isg/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAmE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,IAAI,GACR,OAAO,CAAC,OAAO,CAAC,CAgKlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CA2ErB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CAUrB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/isg/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAoE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,IAAI,GACR,OAAO,CAAC,OAAO,CAAC,CAgKlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CAqFrB;AAkDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,EAChB,UAAU,UAAQ,GACjB,OAAO,CAAC,UAAU,CAAC,CA4CrB"}

package/dist/core/isg/builder.js

@@ -2,6 +2,7 @@ import { computeContentHash, computeFileHash, computeInputsHash } from './hash.j
 import { trackTemplateDependencies } from './deps.js';
 import { computeEffectiveTTL, computeNextRebuildAt, isPageFrozen } from './ttl.js';
 import { validatePageISGOverrides, extractNumericOverride } from './validation.js';
+import { performance } from 'node:perf_hooks';
 /**
  * Determines the output path for a page.
  */
@@ -214,13 +215,21 @@ export async function shouldRebuildPage(page, entry, config, now) {
  * ```
  */
 export async function createCacheEntry(page, config, renderedAt) {
+    const timings = {};
+    let start = performance.now();
     // Validate page-level ISG overrides first
     validatePageISGOverrides(page.frontMatter, page.sourcePath);
+    timings.validate = performance.now() - start;
     // Compute content hash
+    start = performance.now();
     const contentHash = computeContentHash(page.content, page.frontMatter);
+    timings.contentHash = performance.now() - start;
     // Track all template dependencies
+    start = performance.now();
     const deps = await trackTemplateDependencies(page, config);
+    timings.trackDeps = performance.now() - start;
     // Compute hashes for all dependencies
+    start = performance.now();
     const depsHashes = [];
     for (const dep of deps) {
         const depHash = await computeFileHash(dep);
@@ -228,6 +237,7 @@ export async function createCacheEntry(page, config, renderedAt) {
             depsHashes.push(depHash);
         }
     }
+    timings.depsHashes = performance.now() - start;
     const inputsHash = computeInputsHash(contentHash, depsHashes);
     // Extract tags from front matter
     let tags = [];
@@ -271,13 +281,60 @@ export async function createCacheEntry(page, config, renderedAt) {
     }
     return cacheEntry;
 }
+/**
+ * Checks if the template structure has changed by comparing the layout file's
+ * modification time against when the cache entry was last rendered.
+ * This detects when new includes/extends have been added to templates.
+ *
+ * @param entry - The existing cache entry
+ * @returns True if template structure may have changed, false if structure is unchanged
+ */
+async function hasTemplateStructureChanged(entry) {
+    try {
+        // If the entry has a layout in its deps, check if that layout file has been modified
+        // since the last render. Layout files are typically the first dep or contain the
+        // includes/extends declarations.
+        if (entry.deps.length === 0) {
+            return false;
+        }
+        // Get the timestamp of the last render
+        const lastRendered = new Date(entry.renderedAt).getTime();
+        // Import stat from node:fs/promises at runtime to avoid circular dependency issues
+        const { stat } = await import('node:fs/promises');
+        // Check if any template files (layout or partials) have been modified
+        // We only need to check the first few deps (usually layout and immediate includes)
+        // as a heuristic to detect structural changes without expensive full tracking
+        const depsToCheck = entry.deps.slice(0, 3);
+        for (const depPath of depsToCheck) {
+            try {
+                const stats = await stat(depPath);
+                if (stats.mtimeMs > lastRendered) {
+                    // Template file was modified after last render - structure may have changed
+                    return true;
+                }
+            }
+            catch (_error) {
+                // If we can't stat the file, assume it might have changed
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (_error) {
+        // On any error, be conservative and assume structure changed
+        return true;
+    }
+}
 /**
  * Updates an existing cache entry with new information after rebuilding.
+ * In dev mode, this is optimized to reuse the existing deps array since
+ * template structure rarely changes between incremental rebuilds.
  *
  * @param entry - Existing cache entry
  * @param page - The page model
  * @param config - Stati configuration
  * @param renderedAt - When the page was rendered
+ * @param fastUpdate - If true, skip expensive dep tracking (dev mode optimization)
  * @returns Updated cache entry
  *
  * @example
@@ -285,8 +342,38 @@ export async function createCacheEntry(page, config, renderedAt) {
  * const updatedEntry = await updateCacheEntry(existingEntry, page, config, new Date());
  * ```
  */
-export async function updateCacheEntry(entry, page, config, renderedAt) {
-    // Create a new entry and preserve the original publishedAt if not overridden
+export async function updateCacheEntry(entry, page, config, renderedAt, fastUpdate = false) {
+    // In fast update mode (dev), reuse existing deps to avoid expensive tracking
+    if (fastUpdate && entry.deps.length > 0) {
+        // Detect if template structure has changed (new includes/extends added)
+        // by checking if the layout file has been modified or if template content
+        // contains different dependency patterns
+        const structureChanged = await hasTemplateStructureChanged(entry);
+        if (structureChanged) {
+            // Template structure changed - fall through to full dependency tracking
+            // This ensures we pick up new includes/extends
+        }
+        else {
+            // Structure unchanged - safe to reuse existing deps
+            // Just update the content hash and timestamp, keep existing deps
+            const contentHash = computeContentHash(page.content, page.frontMatter);
+            // Compute hashes for existing dependencies (fast - files are cached)
+            const depsHashes = [];
+            for (const dep of entry.deps) {
+                const depHash = await computeFileHash(dep);
+                if (depHash) {
+                    depsHashes.push(depHash);
+                }
+            }
+            const inputsHash = computeInputsHash(contentHash, depsHashes);
+            return {
+                ...entry,
+                inputsHash,
+                renderedAt: renderedAt.toISOString(),
+            };
+        }
+    }
+    // Full update - create new entry and preserve original publishedAt
     const newEntry = await createCacheEntry(page, config, renderedAt);
     // Preserve original publishedAt if no new one is specified
     if (!newEntry.publishedAt && entry.publishedAt) {

package/dist/core/isg/deps.d.ts

@@ -1,4 +1,9 @@
 import type { PageModel, StatiConfig } from '../../types/index.js';
+/**
+ * Clears the template path and content caches.
+ * Should be called at the start of each build.
+ */
+export declare function clearTemplatePathCache(): void;
 /**
  * Error thrown when a circular dependency is detected in templates.
  */

package/dist/core/isg/deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/core/isg/deps.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGnE;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CA+CnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/core/isg/deps.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAenE;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CA+CnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}

package/dist/core/isg/deps.js

@@ -2,6 +2,24 @@ import { join, dirname, relative, posix } from 'node:path';
 import { pathExists, readFile, isCollectionIndexPage, discoverLayout, resolveSrcDir, } from '../utils/index.js';
 import glob from 'fast-glob';
 import { TEMPLATE_EXTENSION } from '../../constants.js';
+/**
+ * Per-build cache for template path resolution (glob results).
+ * Cleared at the start of each build via clearTemplatePathCache().
+ */
+const templatePathCache = new Map();
+/**
+ * Per-build cache for template content reads.
+ * Cleared at the start of each build via clearTemplatePathCache().
+ */
+const templateContentCache = new Map();
+/**
+ * Clears the template path and content caches.
+ * Should be called at the start of each build.
+ */
+export function clearTemplatePathCache() {
+    templatePathCache.clear();
+    templateContentCache.clear();
+}
 /**
  * Error thrown when a circular dependency is detected in templates.
  */
@@ -132,8 +150,15 @@ async function collectTemplateDependencies(templatePath, srcDir, visited, curren
     currentPath.add(normalizedPath);
     visited.add(normalizedPath);
     try {
-        // Read template content to find includes/extends
-        const content = await readFile(templatePath, 'utf-8');
+        // Read template content to find includes/extends (use cache)
+        let content;
+        if (templateContentCache.has(normalizedPath)) {
+            content = templateContentCache.get(normalizedPath);
+        }
+        else {
+            content = await readFile(templatePath, 'utf-8');
+            templateContentCache.set(normalizedPath, content ?? null);
+        }
         if (!content) {
             return;
         }
@@ -274,12 +299,19 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
  * @returns Absolute path to template file, or null if not found
  */
 async function resolveTemplatePathInternal(templateRef, srcDir, currentDir) {
+    // Create cache key from all inputs
+    const cacheKey = `${templateRef}|${srcDir}|${currentDir ?? ''}`;
+    // Check cache first
+    if (templatePathCache.has(cacheKey)) {
+        return templatePathCache.get(cacheKey) ?? null;
+    }
     const templateName = templateRef.endsWith(TEMPLATE_EXTENSION)
         ? templateRef
         : `${templateRef}${TEMPLATE_EXTENSION}`;
     // Try absolute path from srcDir
     const absolutePath = join(srcDir, templateName);
     if (await pathExists(absolutePath)) {
+        templatePathCache.set(cacheKey, absolutePath);
         return absolutePath;
     }
     // Determine the starting directory for hierarchical search (relative to srcDir)
@@ -318,7 +350,9 @@ async function resolveTemplatePathInternal(templateRef, srcDir, currentDir) {
             const matches = await glob(pattern, { absolute: true });
             if (matches.length > 0) {
                 // Normalize to POSIX format for consistent cross-platform path handling
-                return matches[0].replace(/\\/g, '/');
+                const result = matches[0].replace(/\\/g, '/');
+                templatePathCache.set(cacheKey, result);
+                return result;
             }
         }
         catch {
@@ -326,5 +360,6 @@ async function resolveTemplatePathInternal(templateRef, srcDir, currentDir) {
             continue;
         }
     }
+    templatePathCache.set(cacheKey, null);
     return null;
 }

package/dist/core/isg/dev-server-lock.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Dev server lock information stored in the lock file.
+ */
+interface DevServerLock {
+    pid: number;
+    timestamp: string;
+    hostname?: string;
+}
+/**
+ * Manages dev server locking to prevent multiple dev servers from running in the same directory.
+ * Uses a simple file-based locking mechanism with process ID tracking.
+ */
+export declare class DevServerLockManager {
+    private lockPath;
+    private isLocked;
+    private cleanupHandlersRegistered;
+    constructor(cacheDir: string);
+    /**
+     * Attempts to acquire a dev server lock.
+     * Throws an error if another dev server is already running.
+     *
+     * @throws {Error} When lock cannot be acquired
+     *
+     * @example
+     * ```typescript
+     * const lockManager = new DevServerLockManager('.stati');
+     * try {
+     *   await lockManager.acquireLock();
+     *   // Start dev server
+     * } finally {
+     *   await lockManager.releaseLock();
+     * }
+     * ```
+     */
+    acquireLock(): Promise<void>;
+    /**
+     * Releases the dev server lock if this process owns it.
+     *
+     * @example
+     * ```typescript
+     * await lockManager.releaseLock();
+     * ```
+     */
+    releaseLock(): Promise<void>;
+    /**
+     * Checks if a dev server lock is currently held by any process.
+     *
+     * @returns True if a lock exists and the owning process is running
+     */
+    isLockHeld(): Promise<boolean>;
+    /**
+     * Gets information about the current lock holder.
+     *
+     * @returns Lock information or null if no lock exists
+     */
+    getLockInfo(): Promise<DevServerLock | null>;
+    /**
+     * Force removes the lock file without checking ownership.
+     * Should only be used in error recovery scenarios.
+     */
+    private forceRemoveLock;
+    /**
+     * Creates a new lock file with current process information.
+     */
+    private createLockFile;
+    /**
+     * Reads and parses the lock file.
+     */
+    private readLockFile;
+    /**
+     * Checks if a process with the given PID is currently running.
+     */
+    private isProcessRunning;
+    /**
+     * Gets the hostname for lock identification.
+     */
+    private getHostname;
+    /**
+     * Registers process exit handlers to ensure lock is released.
+     * This prevents accidentally leaving the lock file behind.
+     */
+    private registerCleanupHandlers;
+}
+export {};
+//# sourceMappingURL=dev-server-lock.d.ts.map

package/dist/core/isg/dev-server-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server-lock.d.ts","sourceRoot":"","sources":["../../../src/core/isg/dev-server-lock.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,yBAAyB,CAAS;gBAE9B,QAAQ,EAAE,MAAM;IAI5B;;;;;;;;;;;;;;;;OAgBG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDlC;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBlC;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAiBpC;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAYlD;;;OAGG;YACW,eAAe;IAQ7B;;OAEG;YACW,cAAc;IAc5B;;OAEG;YACW,YAAY;IAY1B;;OAEG;YACW,gBAAgB;IAY9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;CAkDhC"}