@stati/core 1.29.2 → 2.0.1

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

@@ -1,79 +1,17 @@
-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.
- */
-export declare class CircularDependencyError extends Error {
-    readonly dependencyChain: string[];
-    constructor(dependencyChain: string[], message: string);
-}
-/**
- * Tracks template dependencies for a given page by parsing template content.
- * Only includes templates that are actually referenced (via include, layout, or stati.partials calls).
- * This provides accurate dependency tracking for ISG cache invalidation.
- *
- * The function recursively parses the layout template and all its dependencies to build
- * the complete dependency tree. This ensures that changes to unused partials don't
- * trigger unnecessary page rebuilds.
- *
- * @param page - The page model to track dependencies for
- * @param config - Stati configuration
- * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
- * @returns Array of absolute paths to actually-used template files (POSIX format)
- * @throws {CircularDependencyError} When circular dependencies are detected in templates
- *
- * @example
- * ```typescript
- * try {
- *   const deps = await trackTemplateDependencies(page, config, allPages);
- *   console.log(`Page depends on ${deps.length} template files`);
- * } catch (error) {
- *   if (error instanceof CircularDependencyError) {
- *     console.error(`Circular dependency: ${error.dependencyChain.join(' -> ')}`);
- *   }
- * }
- * ```
- */
-export declare function trackTemplateDependencies(page: PageModel, config: StatiConfig, allPages: PageModel[]): Promise<string[]>;
+import type { PageModel } from '../../types/index.js';
+import type { TemplateIndex } from '../template-index.js';
 /**
  * Resolves the layout a page renders with, in the form stored as the first entry of its
  * cache dependencies. Uses the same lookup as rendering, so callers can tell whether the
- * page's layout has changed since its dependencies were recorded.
+ * page's layout has changed since it rendered, for example when a collection gains its first
+ * child page and switches to `index.eta`.
+ *
+ * The other templates a page uses are recorded while it renders.
  *
  * @param page - The page model to resolve the layout for
- * @param config - Stati configuration
  * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
+ * @param index - The build's template index
  * @returns Absolute path to the layout file (POSIX format), or null if no layout applies
  */
-export declare function resolveLayoutDependency(page: PageModel, config: StatiConfig, allPages: PageModel[]): Promise<string | null>;
-/**
- * Resolves the Open Graph template a page renders with, when Open Graph images are on and the
- * page does not opt out. Pages that use the built-in template have no file dependency.
- *
- * @param page - The page model
- * @param config - Stati configuration
- * @returns Absolute path to the template (POSIX format), or null
- */
-export declare function resolveOgTemplateDependency(page: PageModel, config: StatiConfig): Promise<string | null>;
-/**
- * Resolves a template name to its file path.
- * Used for explicit layout specifications in front matter.
- *
- * @param layout - Layout name (without .eta extension)
- * @param config - Stati configuration
- * @returns Absolute path to template file, or null if not found
- *
- * @example
- * ```typescript
- * const templatePath = await resolveTemplatePath('post', config);
- * if (templatePath) {
- *   console.log(`Found template at: ${templatePath}`);
- * }
- * ```
- */
-export declare function resolveTemplatePath(layout: string, config: StatiConfig): Promise<string | null>;
+export declare function resolveLayoutDependency(page: PageModel, allPages: PageModel[], index: TemplateIndex): string | null;
 //# sourceMappingURL=deps.d.ts.map

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;AAgBnE;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAI7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAAC,MAAM,EAAE,CAAC,CA+CnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAexB;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAexB;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":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,SAAS,EAAE,EACrB,KAAK,EAAE,aAAa,GACnB,MAAM,GAAG,IAAI,CASf"}

package/dist/core/isg/deps.js

@@ -1,411 +1,20 @@
-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, DEFAULT_OG_TEMPLATE } from '../../constants.js';
-import { clearOgTemplateCache, findOgTemplatePath, isOgImageExcluded } from '../../images/og.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();
-    clearOgTemplateCache();
-}
-/**
- * Error thrown when a circular dependency is detected in templates.
- */
-export class CircularDependencyError extends Error {
-    dependencyChain;
-    constructor(dependencyChain, message) {
-        super(message);
-        this.dependencyChain = dependencyChain;
-        this.name = 'CircularDependencyError';
-    }
-}
-/**
- * Tracks template dependencies for a given page by parsing template content.
- * Only includes templates that are actually referenced (via include, layout, or stati.partials calls).
- * This provides accurate dependency tracking for ISG cache invalidation.
- *
- * The function recursively parses the layout template and all its dependencies to build
- * the complete dependency tree. This ensures that changes to unused partials don't
- * trigger unnecessary page rebuilds.
- *
- * @param page - The page model to track dependencies for
- * @param config - Stati configuration
- * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
- * @returns Array of absolute paths to actually-used template files (POSIX format)
- * @throws {CircularDependencyError} When circular dependencies are detected in templates
- *
- * @example
- * ```typescript
- * try {
- *   const deps = await trackTemplateDependencies(page, config, allPages);
- *   console.log(`Page depends on ${deps.length} template files`);
- * } catch (error) {
- *   if (error instanceof CircularDependencyError) {
- *     console.error(`Circular dependency: ${error.dependencyChain.join(' -> ')}`);
- *   }
- * }
- * ```
- */
-export async function trackTemplateDependencies(page, config, allPages) {
-    // Early return if required config values are missing
-    if (!config.srcDir) {
-        console.warn('Config srcDir is missing, cannot track template dependencies');
-        return [];
-    }
-    const deps = [];
-    const srcDir = resolveSrcDir(config);
-    // Track dependencies with circular detection
-    // The visited set will contain all templates that are actually used (not just accessible)
-    const visited = new Set();
-    const currentPath = new Set();
-    // 1. Find the layout file that will be used for this page
-    const absoluteLayoutPath = await resolveLayoutDependency(page, config, allPages);
-    if (absoluteLayoutPath) {
-        deps.push(absoluteLayoutPath);
-        // Recursively traverse the template dependency tree
-        // This populates 'visited' with all actually-used templates (not just accessible ones)
-        await collectTemplateDependencies(absoluteLayoutPath, srcDir, visited, currentPath);
-    }
-    // The Open Graph template renders with the page, so it and its partials are dependencies too.
-    // It comes after the layout, which must stay first.
-    const ogTemplatePath = await resolveOgTemplateDependency(page, config);
-    if (ogTemplatePath) {
-        deps.push(ogTemplatePath);
-        await collectTemplateDependencies(ogTemplatePath, srcDir, visited, currentPath);
-    }
-    // 2. Add all actually-used templates from the visited set
-    // Filter to only include underscore directories (partials/components)
-    // and normalize paths to POSIX format
-    for (const templatePath of visited) {
-        const normalizedPath = templatePath.replace(/\\/g, '/');
-        // Only add partials (files in directories starting with underscore) - layout is already added
-        // Use strict pattern to match /_dirname/ where dirname starts with underscore
-        if (/\/_[^/]+\//.test(normalizedPath)) {
-            deps.push(normalizedPath);
-        }
-    }
-    return deps;
-}
+import { posix, relative } from 'node:path';
+import { isCollectionIndexPage } from '../utils/index.js';
 /**
  * Resolves the layout a page renders with, in the form stored as the first entry of its
  * cache dependencies. Uses the same lookup as rendering, so callers can tell whether the
- * page's layout has changed since its dependencies were recorded.
+ * page's layout has changed since it rendered, for example when a collection gains its first
+ * child page and switches to `index.eta`.
+ *
+ * The other templates a page uses are recorded while it renders.
  *
  * @param page - The page model to resolve the layout for
- * @param config - Stati configuration
  * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
+ * @param index - The build's template index
  * @returns Absolute path to the layout file (POSIX format), or null if no layout applies
  */
-export async function resolveLayoutDependency(page, config, allPages) {
-    if (!config.srcDir) {
-        return null;
-    }
-    const srcDir = resolveSrcDir(config);
-    const layoutPath = await discoverLayout(relative(srcDir, page.sourcePath), config, page.frontMatter.layout, isCollectionIndexPage(page, allPages));
+export function resolveLayoutDependency(page, allPages, index) {
+    const { file } = index.resolvePageLayout(relative(index.srcDir, page.sourcePath).replace(/\\/g, '/'), page.frontMatter.layout, isCollectionIndexPage(page, allPages));
     // Normalize to POSIX format for consistent manifest output across platforms
-    return layoutPath ? posix.join(srcDir.replace(/\\/g, '/'), layoutPath) : null;
-}
-/**
- * Resolves the Open Graph template a page renders with, when Open Graph images are on and the
- * page does not opt out. Pages that use the built-in template have no file dependency.
- *
- * @param page - The page model
- * @param config - Stati configuration
- * @returns Absolute path to the template (POSIX format), or null
- */
-export async function resolveOgTemplateDependency(page, config) {
-    const og = config.images ? config.images.og : undefined;
-    if (!og || !config.srcDir) {
-        return null;
-    }
-    const options = og === true ? {} : og;
-    if (isOgImageExcluded(page, options.exclude ?? [])) {
-        return null;
-    }
-    const templatePath = await findOgTemplatePath(page.sourcePath, resolveSrcDir(config), options.template ?? DEFAULT_OG_TEMPLATE);
-    return templatePath ? templatePath.replace(/\\/g, '/') : null;
-}
-/**
- * Resolves a template name to its file path.
- * Used for explicit layout specifications in front matter.
- *
- * @param layout - Layout name (without .eta extension)
- * @param config - Stati configuration
- * @returns Absolute path to template file, or null if not found
- *
- * @example
- * ```typescript
- * const templatePath = await resolveTemplatePath('post', config);
- * if (templatePath) {
- *   console.log(`Found template at: ${templatePath}`);
- * }
- * ```
- */
-export async function resolveTemplatePath(layout, config) {
-    const srcDir = resolveSrcDir(config);
-    const layoutPath = join(srcDir, `${layout}.eta`);
-    if (await pathExists(layoutPath)) {
-        return layoutPath;
-    }
-    return null;
-}
-/**
- * Recursively collects all template dependencies by parsing template content.
- * Only includes templates that are actually referenced (not just accessible).
- * Uses DFS to traverse the dependency graph and detects circular references.
- *
- * @param templatePath - Absolute path to template file to analyze
- * @param srcDir - Source directory for resolving relative template paths
- * @param visited - Set to track all visited templates (accumulated dependencies)
- * @param currentPath - Set of templates in current DFS path (for cycle detection)
- * @throws {CircularDependencyError} When a circular dependency is detected
- */
-async function collectTemplateDependencies(templatePath, srcDir, visited, currentPath) {
-    // Normalize path for consistent tracking
-    const normalizedPath = templatePath.replace(/\\/g, '/');
-    // Check for circular dependency FIRST (before visited check)
-    // A circular dependency means we're visiting a template that's already in our current DFS path
-    // This must be checked before the visited check because a path in currentPath is always in visited
-    if (currentPath.has(normalizedPath)) {
-        const chain = [...currentPath, normalizedPath];
-        throw new CircularDependencyError(chain, `Circular dependency detected in templates: ${chain.join(' -> ')}`);
-    }
-    // Skip if already processed (but not in current path - those are handled above)
-    if (visited.has(normalizedPath)) {
-        return;
-    }
-    // Check if template file exists
-    if (!(await pathExists(templatePath))) {
-        return;
-    }
-    // Add to tracking sets
-    currentPath.add(normalizedPath);
-    visited.add(normalizedPath);
-    try {
-        // 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;
-        }
-        // Parse template to find referenced templates
-        const dependencies = await parseTemplateDependencies(content, templatePath, srcDir);
-        // Recursively collect dependencies
-        for (const depPath of dependencies) {
-            await collectTemplateDependencies(depPath, srcDir, visited, currentPath);
-        }
-    }
-    catch (error) {
-        // Re-throw circular dependency errors - these are fatal
-        if (error instanceof CircularDependencyError) {
-            throw error;
-        }
-        // Log warning but continue - don't fail the entire build for template parsing issues
-        if (error instanceof Error) {
-            console.warn(`Warning: Could not parse template ${templatePath}: ${error.message}`);
-        }
-    }
-    finally {
-        // Remove from current path when backtracking
-        currentPath.delete(normalizedPath);
-    }
-}
-/**
- * Parses a template file to find included/extended templates.
- * This is a basic implementation that looks for common Eta patterns.
- *
- * @param content - Template file content
- * @param templatePath - Path to the template file (for error context)
- * @param srcDir - Source directory for resolving relative paths
- * @returns Array of absolute paths to dependent templates
- */
-async function parseTemplateDependencies(content, templatePath, srcDir) {
-    const dependencies = [];
-    const templateDir = dirname(templatePath);
-    // Strip comments from template content to avoid false positives
-    // This removes:
-    // 1. Eta block comments: <% /* ... */ %> or <% /** ... */ %>
-    // 2. JavaScript single-line comments within Eta blocks: <% // ... %>
-    // 3. JavaScript block comments within Eta blocks (handles multi-line)
-    const contentWithoutComments = content
-        // Remove JS block comments (/* ... */) - handles multi-line
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        // Remove JS single-line comments (// ...) but only within Eta blocks
-        // This is tricky - we'll be conservative and just remove // comments to end of line
-        .replace(/\/\/[^\n]*/g, '');
-    // Look for Eta include patterns: <%~ include('template') %>
-    const includePatterns = [
-        /<%[~-]?\s*include\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
-        /<%[~-]?\s*include\s*\(\s*['"`]([^'"`]+)['"`]\s*,/g, // with parameters
-    ];
-    for (const pattern of includePatterns) {
-        let match;
-        while ((match = pattern.exec(contentWithoutComments)) !== null) {
-            const includePath = match[1];
-            if (includePath) {
-                const resolvedPath = await resolveTemplatePathInternal(includePath, srcDir, templateDir);
-                if (resolvedPath) {
-                    dependencies.push(resolvedPath);
-                }
-            }
-        }
-    }
-    // Look for Eta layout/extends patterns: <%~ layout('template') %>
-    const layoutPatterns = [
-        /<%[~-]?\s*layout\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
-        /<%[~-]?\s*extends?\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
-    ];
-    for (const pattern of layoutPatterns) {
-        let match;
-        while ((match = pattern.exec(contentWithoutComments)) !== null) {
-            const layoutPath = match[1];
-            if (layoutPath) {
-                const resolvedPath = await resolveTemplatePathInternal(layoutPath, srcDir, templateDir);
-                if (resolvedPath) {
-                    dependencies.push(resolvedPath);
-                }
-            }
-        }
-    }
-    // Look for Stati partial patterns - both callable and non-callable
-    // Callable: stati.partials.name() or stati.partials['name']()
-    // Non-callable: stati.partials.name or stati.partials['name'] (used with <%~ %>)
-    const partialPatterns = [
-        // Callable patterns (with parentheses)
-        /stati\.partials\.(\w+)\s*\(/g, // stati.partials.header(
-        /stati\.partials\[['"`]([^'"`]+)['"`]\]\s*\(/g, // stati.partials['header'](
-        // Non-callable patterns (without parentheses, used in <%~ stati.partials.name %>)
-        // These patterns use lookaheads to distinguish between:
-        //   - stati.partials.name (partial reference, should match)
-        //   - stati.partials.name() (function call, should NOT match here - handled above)
-        //
-        // Pattern breakdown for dot notation: /stati\.partials\.(\w+)(?=\s*[%}\s]|$)(?!\s*\()/g
-        //   - stati\.partials\.  : Literal "stati.partials."
-        //   - (\w+)              : Capture partial name (letters, digits, underscore)
-        //   - (?=\s*[%}\s]|$)    : Positive lookahead - must be followed by whitespace, %, }, or end of string
-        //   - (?!\s*\()          : Negative lookahead - must NOT be followed by "(" (excludes function calls)
-        /stati\.partials\.(\w+)(?=\s*[%}\s]|$)(?!\s*\()/g,
-        // Pattern breakdown for bracket notation: /stati\.partials\[['"`]([^'"`]+)['"`]\](?=\s*[%}\s]|$)(?!\s*\()/g
-        //   - stati\.partials\[  : Literal "stati.partials["
-        //   - ['"`]              : Opening quote (single, double, or backtick)
-        //   - ([^'"`]+)          : Capture partial name (any chars except quotes)
-        //   - ['"`]\]            : Closing quote and bracket
-        //   - (?=\s*[%}\s]|$)    : Positive lookahead - must be followed by whitespace, %, }, or end of string
-        //   - (?!\s*\()          : Negative lookahead - must NOT be followed by "(" (excludes function calls)
-        /stati\.partials\[['"`]([^'"`]+)['"`]\](?=\s*[%}\s]|$)(?!\s*\()/g,
-    ];
-    // Use a Set to avoid duplicate partial names
-    const foundPartials = new Set();
-    for (const pattern of partialPatterns) {
-        let match;
-        while ((match = pattern.exec(contentWithoutComments)) !== null) {
-            const partialName = match[1];
-            if (partialName) {
-                foundPartials.add(partialName);
-            }
-        }
-    }
-    // Resolve each unique partial name
-    for (const partialName of foundPartials) {
-        const partialFileName = `${partialName}${TEMPLATE_EXTENSION}`;
-        const resolvedPath = await resolveTemplatePathInternal(partialFileName, srcDir, templateDir);
-        if (resolvedPath) {
-            dependencies.push(resolvedPath);
-        }
-    }
-    return dependencies;
-}
-/**
- * Internal helper to resolve template paths (renamed to avoid naming conflict).
- * Handles relative paths and adds .eta extension if needed.
- *
- * @param templateRef - Template reference from include/layout statement
- * @param srcDir - Source directory for resolving paths
- * @param currentDir - Current directory for hierarchical search (optional)
- * @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)
-    const startDir = currentDir ? relative(srcDir, currentDir) : '';
-    // Build list of directories to search (current dir up to srcDir root only)
-    // This ensures we never search outside the source directory boundary
-    const dirsToSearch = [];
-    // Safety check: ensure currentDir is within srcDir (relative path shouldn't start with '..')
-    if (startDir.startsWith('..')) {
-        // If currentDir is outside srcDir, only search at srcDir root
-        dirsToSearch.push('');
-    }
-    else {
-        const pathSegments = startDir === '' ? [] : startDir.split(/[/\\]/);
-        // Add directories from current up to srcDir root (don't go beyond srcDir)
-        if (pathSegments.length > 0) {
-            for (let i = pathSegments.length; i >= 0; i--) {
-                if (i === 0) {
-                    dirsToSearch.push(''); // srcDir root directory
-                }
-                else {
-                    dirsToSearch.push(pathSegments.slice(0, i).join('/'));
-                }
-            }
-        }
-        else {
-            dirsToSearch.push(''); // srcDir root directory only
-        }
-    }
-    // Search each directory level for the template in underscore directories
-    for (const dir of dirsToSearch) {
-        const searchDir = dir ? join(srcDir, dir) : srcDir;
-        try {
-            // Search for template in underscore directories at this level only
-            const pattern = posix.join(searchDir.replace(/\\/g, '/'), '_*', templateName);
-            const matches = await glob(pattern, { absolute: true });
-            if (matches.length > 0) {
-                // Normalize to POSIX format for consistent cross-platform path handling
-                const result = matches[0].replace(/\\/g, '/');
-                templatePathCache.set(cacheKey, result);
-                return result;
-            }
-        }
-        catch {
-            // Continue if directory doesn't exist or can't be read
-            continue;
-        }
-    }
-    templatePathCache.set(cacheKey, null);
-    return null;
+    return file ? posix.join(index.srcDir.replace(/\\/g, '/'), file) : null;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AAgCA;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8B9E;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAAE,EACpB,gBAAgB,CAAC,EAAE,MAAM,GACxB,MAAM,CASR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,MAAM,CA+CnE"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AAgCA;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA+B9E;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAAE,EACpB,gBAAgB,CAAC,EAAE,MAAM,GACxB,MAAM,CASR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,MAAM,CA+CnE"}

package/dist/core/isg/hash.js

@@ -94,7 +94,8 @@ export async function computeFileHash(filePath) {
             return null;
         }
         const content = await readFile(filePath, 'utf-8');
-        if (!content) {
+        // An empty file has a hash too: a page that includes an empty template must stay cached
+        if (content === null) {
             fileHashCache.set(normalizedPath, null);
             return null;
         }

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

@@ -7,12 +7,12 @@
  * @module isg
  */
 export { loadCacheManifest, saveCacheManifest, createEmptyManifest } from './manifest.js';
-export { shouldRebuildPage, createCacheEntry, updateCacheEntry, hasRecordedReads, } from './builder.js';
+export { shouldRebuildPage, createCacheEntry, updateCacheEntry, hasRecordedReads, hasRecordedTemplates, } from './builder.js';
 export type { RenderedAssets } from './builder.js';
 export { pruneOrphanedPages } from './prune.js';
 export { BuildLockManager, withBuildLock } from './build-lock.js';
 export { DevServerLockManager } from './dev-server-lock.js';
-export { CircularDependencyError, trackTemplateDependencies, resolveTemplatePath, clearTemplatePathCache, } from './deps.js';
+export { resolveLayoutDependency } from './deps.js';
 export { computeContentHash, computeFileHash, computeBinaryFileHash, computeInputsHash, computeNavigationHash, clearFileHashCache, } from './hash.js';
 export { getSafeCurrentTime, parseSafeDate, computeEffectiveTTL, computeNextRebuildAt, isPageFrozen, applyAgingRules, } from './ttl.js';
 export { ISGConfigurationError, validateISGConfig, validatePageISGOverrides, extractNumericOverride, } from './validation.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/isg/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAG1F,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,OAAO,EACL,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,eAAe,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/isg/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAG1F,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAGpD,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,eAAe,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC"}

package/dist/core/isg/index.js

@@ -9,14 +9,14 @@
 // Manifest management
 export { loadCacheManifest, saveCacheManifest, createEmptyManifest } from './manifest.js';
 // Build decision logic
-export { shouldRebuildPage, createCacheEntry, updateCacheEntry, hasRecordedReads, } from './builder.js';
+export { shouldRebuildPage, createCacheEntry, updateCacheEntry, hasRecordedReads, hasRecordedTemplates, } from './builder.js';
 // Removal of pages that no longer exist
 export { pruneOrphanedPages } from './prune.js';
 // Build locking
 export { BuildLockManager, withBuildLock } from './build-lock.js';
 export { DevServerLockManager } from './dev-server-lock.js';
-// Dependency tracking
-export { CircularDependencyError, trackTemplateDependencies, resolveTemplatePath, clearTemplatePathCache, } from './deps.js';
+// The layout a page renders with; every other template is recorded while it renders
+export { resolveLayoutDependency } from './deps.js';
 // Hash computation
 export { computeContentHash, computeFileHash, computeBinaryFileHash, computeInputsHash, computeNavigationHash, clearFileHashCache, } from './hash.js';
 // TTL and aging

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

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/core/isg/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,sBAAsB,CAAC;AAUtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAsGvF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAyEhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAInD"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/core/isg/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,sBAAsB,CAAC;AAWtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAsGvF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAyEhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAInD"}

package/dist/core/isg/manifest.js

@@ -1,6 +1,7 @@
 import { readFile, writeFile, pathExists, ensureDir } from '../utils/index.js';
 import { join } from 'node:path';
 import { MANIFEST_FILENAME } from '../../constants.js';
+import { isTemplateLookupList } from '../template-index.js';
 /**
  * Loads the ISG cache manifest from the cache directory.
  * Returns null if no manifest exists or if it's corrupted.
@@ -237,12 +238,16 @@ function validateCacheEntry(entry, path) {
             return false;
         }
     }
-    for (const field of ['readsCollection', 'readsNav']) {
+    for (const field of ['readsCollection', 'readsNav', 'templatesRecorded']) {
         if (entryObj[field] !== undefined && typeof entryObj[field] !== 'boolean') {
             console.warn(`Invalid cache entry for ${path}: "${field}" must be a boolean if present`);
             return false;
         }
     }
+    if (entryObj.templateLookups !== undefined && !isTemplateLookupList(entryObj.templateLookups)) {
+        console.warn(`Invalid cache entry for ${path}: "templateLookups" must be a list of { name, from?, file } objects`);
+        return false;
+    }
     // Validate that deps and tags arrays contain strings
     if (!entryObj.deps.every((dep) => typeof dep === 'string')) {
         console.warn(`Invalid cache entry for ${path}: all "deps" must be strings`);

package/dist/core/markdown.d.ts

@@ -1,4 +1,4 @@
-import MarkdownIt from 'markdown-it';
+import { type MarkdownIt } from 'markdown-it';
 import type { StatiConfig, TocEntry } from '../types/index.js';
 import type { PageImages } from '../images/runtime.js';
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,aAAa,CAAC;AAKrC,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAI/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,GAAG,EAAE,QAAQ,EAAE,CAAC;CACjB;AAQD;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAmBD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAsDtF;AA6ED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,QAAQ,EAAE,CAGtE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,qFAAqF;IACrF,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,UAAU,EACd,UAAU,GAAE,OAAc,EAC1B,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAkBhB"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AACA,OAA8B,EAAE,KAAK,UAAU,EAAc,MAAM,aAAa,CAAC;AAIjF,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAI/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,GAAG,EAAE,QAAQ,EAAE,CAAC;CACjB;AAQD;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAmBD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAsDtF;AA6ED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,QAAQ,EAAE,CAGtE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,qFAAqF;IACrF,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,UAAU,EACd,UAAU,GAAE,OAAc,EAC1B,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAkBhB"}

package/dist/core/markdown.js

@@ -1,4 +1,5 @@
-import MarkdownIt from 'markdown-it';
+// markdown-it's default export is a value only; the instance type is its named `MarkdownIt` export
+import MarkdownItConstructor from 'markdown-it';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import path from 'node:path';
@@ -44,7 +45,7 @@ export async function createMarkdownProcessor(config) {
     if (isDevelopment() && cachedMarkdownProcessor) {
         return cachedMarkdownProcessor;
     }
-    const md = new MarkdownIt({
+    const md = new MarkdownItConstructor({
         html: true,
         linkify: true,
         typographer: true,