@stati/core 1.3.1 → 1.4.0

package/dist/core/isg/deps.js

@@ -1,7 +1,9 @@
 import { join, dirname, relative, posix } from 'path';
-import fse from 'fs-extra';
-const { pathExists, readFile } = fse;
+import { pathExists, readFile } from '../utils/fs.js';
 import glob from 'fast-glob';
+import { TEMPLATE_EXTENSION } from '../../constants.js';
+import { isCollectionIndexPage, discoverLayout } from '../utils/template-discovery.js';
+import { resolveSrcDir } from '../utils/paths.js';
 /**
  * Error thrown when a circular dependency is detected in templates.
  */
@@ -42,7 +44,7 @@ export async function trackTemplateDependencies(page, config) {
         return [];
     }
     const deps = [];
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     const relativePath = relative(srcDir, page.sourcePath);
     // Track dependencies with circular detection
     const visited = new Set();
@@ -80,7 +82,7 @@ export async function findPartialDependencies(pagePath, config) {
         return [];
     }
     const deps = [];
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     // Get the directory of the current page
     const pageDir = dirname(pagePath);
     const pathSegments = pageDir === '.' ? [] : pageDir.split(/[/\\]/);
@@ -135,71 +137,13 @@ export async function findPartialDependencies(pagePath, config) {
  * ```
  */
 export async function resolveTemplatePath(layout, config) {
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     const layoutPath = join(srcDir, `${layout}.eta`);
     if (await pathExists(layoutPath)) {
         return layoutPath;
     }
     return null;
 }
-/**
- * Helper function to determine if a page is a collection index page.
- * Duplicated from templates.ts to avoid circular dependencies.
- */
-function isCollectionIndexPage(page) {
-    // This is a simplified version - in a real implementation,
-    // we'd need access to all pages to determine this properly.
-    // For now, we'll assume any page ending in /index or at root is a collection page.
-    return page.url === '/' || page.url.endsWith('/index') || page.slug === 'index';
-}
-/**
- * Helper function to discover layout files.
- * Duplicated from templates.ts to avoid circular dependencies.
- */
-async function discoverLayout(pagePath, config, explicitLayout, isIndexPage) {
-    // Early return if required config values are missing
-    if (!config.srcDir) {
-        return null;
-    }
-    const srcDir = join(process.cwd(), config.srcDir);
-    // If explicit layout is specified, use it
-    if (explicitLayout) {
-        const layoutPath = join(srcDir, `${explicitLayout}.eta`);
-        if (await pathExists(layoutPath)) {
-            return `${explicitLayout}.eta`;
-        }
-    }
-    // Get the directory of the current page
-    const pageDir = dirname(pagePath);
-    const pathSegments = pageDir === '.' ? [] : pageDir.split(/[/\\]/);
-    // Search for layout.eta from current directory up to root
-    const dirsToSearch = [];
-    // Add current directory if not root
-    if (pathSegments.length > 0) {
-        for (let i = pathSegments.length; i > 0; i--) {
-            dirsToSearch.push(pathSegments.slice(0, i).join('/'));
-        }
-    }
-    // Add root directory
-    dirsToSearch.push('');
-    for (const dir of dirsToSearch) {
-        // For index pages, first check for index.eta in each directory
-        if (isIndexPage) {
-            const indexLayoutPath = dir ? join(srcDir, dir, 'index.eta') : join(srcDir, 'index.eta');
-            if (await pathExists(indexLayoutPath)) {
-                const relativePath = dir ? `${dir}/index.eta` : 'index.eta';
-                return posix.normalize(relativePath);
-            }
-        }
-        // Then check for layout.eta as fallback
-        const layoutPath = dir ? join(srcDir, dir, 'layout.eta') : join(srcDir, 'layout.eta');
-        if (await pathExists(layoutPath)) {
-            const relativePath = dir ? `${dir}/layout.eta` : 'layout.eta';
-            return posix.normalize(relativePath);
-        }
-    }
-    return null;
-}
 /**
  * Detects circular dependencies in template includes/extends.
  * Uses DFS to traverse the dependency graph and detect cycles.
@@ -233,6 +177,9 @@ async function detectCircularDependencies(templatePath, srcDir, visited, current
     try {
         // Read template content to find includes/extends
         const content = await readFile(templatePath, 'utf-8');
+        if (!content) {
+            return; // Skip if file doesn't exist
+        }
         const dependencies = await parseTemplateDependencies(content, templatePath, srcDir);
         // Recursively check dependencies
         for (const depPath of dependencies) {
@@ -264,6 +211,7 @@ async function detectCircularDependencies(templatePath, srcDir, visited, current
  */
 async function parseTemplateDependencies(content, templatePath, srcDir) {
     const dependencies = [];
+    const templateDir = dirname(templatePath);
     // Look for Eta include patterns: <%~ include('template') %>
     const includePatterns = [
         /<%[~-]?\s*include\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
@@ -274,7 +222,7 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
         while ((match = pattern.exec(content)) !== null) {
             const includePath = match[1];
             if (includePath) {
-                const resolvedPath = await resolveTemplatePathInternal(includePath, srcDir);
+                const resolvedPath = await resolveTemplatePathInternal(includePath, srcDir, templateDir);
                 if (resolvedPath) {
                     dependencies.push(resolvedPath);
                 }
@@ -291,7 +239,7 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
         while ((match = pattern.exec(content)) !== null) {
             const layoutPath = match[1];
             if (layoutPath) {
-                const resolvedPath = await resolveTemplatePathInternal(layoutPath, srcDir);
+                const resolvedPath = await resolveTemplatePathInternal(layoutPath, srcDir, templateDir);
                 if (resolvedPath) {
                     dependencies.push(resolvedPath);
                 }
@@ -306,26 +254,59 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
  *
  * @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) {
-    // Add .eta extension if not present
-    const templateName = templateRef.endsWith('.eta') ? templateRef : `${templateRef}.eta`;
+async function resolveTemplatePathInternal(templateRef, srcDir, currentDir) {
+    const templateName = templateRef.endsWith(TEMPLATE_EXTENSION)
+        ? templateRef
+        : `${templateRef}${TEMPLATE_EXTENSION}`;
     // Try absolute path from srcDir
     const absolutePath = join(srcDir, templateName);
     if (await pathExists(absolutePath)) {
         return absolutePath;
     }
-    // Try resolving relative to template directories
-    // This is a simplified version - real implementation might need more sophisticated resolution
-    const possiblePaths = [
-        join(srcDir, '_templates', templateName),
-        join(srcDir, '_partials', templateName),
-        join(srcDir, '_layouts', templateName),
-    ];
-    for (const path of possiblePaths) {
-        if (await pathExists(path)) {
-            return path;
+    // 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) {
+                return matches[0]; // Return first match
+            }
+        }
+        catch {
+            // Continue if directory doesn't exist or can't be read
+            continue;
         }
     }
     return 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":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAWhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAanF"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAKhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAKnF"}

package/dist/core/isg/hash.js

@@ -1,6 +1,24 @@
 import { createHash } from 'crypto';
-import fse from 'fs-extra';
-const { readFile, pathExists } = fse;
+import { readFile, pathExists } from '../utils/fs.js';
+/**
+ * Creates a SHA-256 hash instance, updates it with data, and returns the hex digest.
+ * Internal utility to eliminate duplicate hash creation patterns.
+ *
+ * @param data - Data to hash
+ * @returns SHA-256 hash as a hex string with 'sha256-' prefix
+ */
+function createSha256Hash(data) {
+    const hash = createHash('sha256');
+    if (Array.isArray(data)) {
+        for (const item of data) {
+            hash.update(item, 'utf-8');
+        }
+    }
+    else {
+        hash.update(data, 'utf-8');
+    }
+    return `sha256-${hash.digest('hex')}`;
+}
 /**
  * Computes a SHA-256 hash of page content and front matter.
  * Used to detect when page content has changed.
@@ -16,13 +34,9 @@ const { readFile, pathExists } = fse;
  * ```
  */
 export function computeContentHash(content, frontMatter) {
-    const hash = createHash('sha256');
-    // Hash the content
-    hash.update(content, 'utf-8');
     // Hash the front matter (sorted for consistency)
     const sortedFrontMatter = JSON.stringify(frontMatter, Object.keys(frontMatter).sort());
-    hash.update(sortedFrontMatter, 'utf-8');
-    return `sha256-${hash.digest('hex')}`;
+    return createSha256Hash([content, sortedFrontMatter]);
 }
 /**
  * Computes a SHA-256 hash of a file's contents.
@@ -45,9 +59,10 @@ export async function computeFileHash(filePath) {
             return null;
         }
         const content = await readFile(filePath, 'utf-8');
-        const hash = createHash('sha256');
-        hash.update(content, 'utf-8');
-        return `sha256-${hash.digest('hex')}`;
+        if (!content) {
+            return null;
+        }
+        return createSha256Hash(content);
     }
     catch (error) {
         console.warn(`Failed to compute hash for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -70,13 +85,7 @@ export async function computeFileHash(filePath) {
  * ```
  */
 export function computeInputsHash(contentHash, depsHashes) {
-    const hash = createHash('sha256');
-    // Hash the content hash
-    hash.update(contentHash, 'utf-8');
     // Hash each dependency hash in sorted order for consistency
     const sortedDepsHashes = [...depsHashes].sort();
-    for (const depHash of sortedDepsHashes) {
-        hash.update(depHash, 'utf-8');
-    }
-    return `sha256-${hash.digest('hex')}`;
+    return createSha256Hash([contentHash, ...sortedDepsHashes]);
 }

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

@@ -1,4 +1,4 @@
-import type { CacheManifest } from '../../types.js';
+import type { CacheManifest } from '../../types/index.js';
 /**
  * Loads the ISG cache manifest from the cache directory.
  * Returns null if no manifest exists or if it's corrupted.

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":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,gBAAgB,CAAC;AAchE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAyFvF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA6ChG;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;AAUtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA8FvF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAmEhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAInD"}

package/dist/core/isg/manifest.js

@@ -1,10 +1,6 @@
-import fse from 'fs-extra';
-const { readFile, writeFile, pathExists, ensureDir } = fse;
+import { readFile, writeFile, pathExists, ensureDir } from '../utils/fs.js';
 import { join } from 'path';
-/**
- * Path to the cache manifest file within the cache directory
- */
-const MANIFEST_FILENAME = 'manifest.json';
+import { MANIFEST_FILENAME } from '../../constants.js';
 /**
  * Loads the ISG cache manifest from the cache directory.
  * Returns null if no manifest exists or if it's corrupted.
@@ -28,6 +24,10 @@ export async function loadCacheManifest(cacheDir) {
             return null;
         }
         const manifestContent = await readFile(manifestPath, 'utf-8');
+        if (!manifestContent) {
+            console.warn('Cache manifest not found or empty, creating new cache');
+            return null;
+        }
         // Handle empty files
         if (!manifestContent.trim()) {
             console.warn('Cache manifest is empty, creating new cache');
@@ -119,11 +119,14 @@ export async function saveCacheManifest(cacheDir, manifest) {
     }
     catch (error) {
         const nodeError = error;
-        if (nodeError.code === 'EACCES') {
+        // Handle specific error codes with custom messages
+        if (nodeError.code === 'EACCES' ||
+            (nodeError.message && nodeError.message.includes('Permission denied'))) {
             throw new Error(`Permission denied saving cache manifest to ${manifestPath}. ` +
                 `Please check directory permissions or run with appropriate privileges.`);
         }
-        if (nodeError.code === 'ENOSPC') {
+        if (nodeError.code === 'ENOSPC' ||
+            (nodeError.message && nodeError.message.includes('No space left on device'))) {
             throw new Error(`No space left on device when saving cache manifest to ${manifestPath}. ` +
                 `Please free up disk space and try again.`);
         }
@@ -135,6 +138,16 @@ export async function saveCacheManifest(cacheDir, manifest) {
             throw new Error(`Cache directory path ${cacheDir} is not a directory. ` +
                 `Please remove the conflicting file and try again.`);
         }
+        // Re-throw the original error if it's already properly formatted
+        if (error instanceof Error) {
+            if (error.message.includes('Failed to create directory') ||
+                error.message.includes('Failed to write file')) {
+                throw new Error(`Failed to save cache manifest to ${manifestPath}: ${error.message.split(': ').slice(-1)[0]}`);
+            }
+            if (error.message.includes('Failed to')) {
+                throw error;
+            }
+        }
         throw new Error(`Failed to save cache manifest to ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
     }
 }

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

@@ -1,4 +1,4 @@
-import type { PageModel, ISGConfig, AgingRule, CacheEntry } from '../../types.js';
+import type { PageModel, ISGConfig, AgingRule, CacheEntry } from '../../types/index.js';
 /**
  * Safely gets the current UTC time with drift protection.
  * Ensures all ISG operations use consistent UTC time.

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

@@ -1 +1 @@
-{"version":3,"file":"ttl.d.ts","sourceRoot":"","sources":["../../../src/core/isg/ttl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAQlF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,CAAC,EAAE,IAAI,GAAG,IAAI,CAW5D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAqB5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,IAAI,GACjB,MAAM,CAkBR;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,GAAG,EAAE,IAAI,CAAC;IACV,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,IAAI,GAAG,IAAI,CAqBd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAiBlE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,IAAI,EACjB,UAAU,EAAE,SAAS,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,IAAI,GACR,MAAM,CAyBR"}
+{"version":3,"file":"ttl.d.ts","sourceRoot":"","sources":["../../../src/core/isg/ttl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAQxF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,CAAC,EAAE,IAAI,GAAG,IAAI,CAW5D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAqB5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,IAAI,GACjB,MAAM,CAkBR;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,GAAG,EAAE,IAAI,CAAC;IACV,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,IAAI,GAAG,IAAI,CAqBd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAiBlE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,IAAI,EACjB,UAAU,EAAE,SAAS,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,IAAI,GACR,MAAM,CAyBR"}

package/dist/core/isg/ttl.js

@@ -1,8 +1,5 @@
-/**
- * Clock drift tolerance in milliseconds.
- * Accounts for small differences between system clocks.
- */
-const CLOCK_DRIFT_TOLERANCE_MS = 30000; // 30 seconds
+import { CLOCK_DRIFT_TOLERANCE_MS, DEFAULT_TTL_SECONDS, MILLISECONDS_PER_DAY, } from '../../constants.js';
+// dedup: time constants centralized in constants.ts
 /**
  * Safely gets the current UTC time with drift protection.
  * Ensures all ISG operations use consistent UTC time.
@@ -73,11 +70,11 @@ export function computeEffectiveTTL(page, isgConfig, currentTime) {
     const now = getSafeCurrentTime(currentTime);
     // Apply aging rules if we have a published date and aging rules configured
     if (publishedAt && isgConfig.aging && isgConfig.aging.length > 0) {
-        const defaultTTL = isgConfig.ttlSeconds ?? 21600; // 6 hours default
+        const defaultTTL = isgConfig.ttlSeconds ?? DEFAULT_TTL_SECONDS;
         return applyAgingRules(publishedAt, isgConfig.aging, defaultTTL, now);
     }
     // Fall back to default TTL
-    return isgConfig.ttlSeconds ?? 21600; // 6 hours default
+    return isgConfig.ttlSeconds ?? DEFAULT_TTL_SECONDS;
 }
 /**
  * Computes the next rebuild date for a page based on TTL and aging rules.
@@ -108,7 +105,7 @@ export function computeNextRebuildAt(options) {
     // If there's a max age cap and published date, check if content is frozen
     if (maxAgeCapDays && publishedAt) {
         const normalizedPublishedAt = getSafeCurrentTime(publishedAt);
-        const maxAgeMs = maxAgeCapDays * 24 * 60 * 60 * 1000;
+        const maxAgeMs = maxAgeCapDays * MILLISECONDS_PER_DAY;
         const ageMs = now.getTime() - normalizedPublishedAt.getTime();
         if (ageMs > maxAgeMs) {
             // Content is frozen, no rebuild needed
@@ -145,7 +142,7 @@ export function isPageFrozen(entry, now) {
         // If we can't parse the published date, don't freeze
         return false;
     }
-    const maxAgeMs = entry.maxAgeCapDays * 24 * 60 * 60 * 1000;
+    const maxAgeMs = entry.maxAgeCapDays * MILLISECONDS_PER_DAY;
     const ageMs = safeNow.getTime() - publishedAt.getTime();
     return ageMs > maxAgeMs;
 }

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

@@ -1,4 +1,4 @@
-import type { ISGConfig } from '../../types.js';
+import type { ISGConfig } from '../../types/index.js';
 /**
  * Error codes for ISG validation failures.
  * These provide structured error identification for better debugging.

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

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/core/isg/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,gBAAgB,CAAC;AAE3D;;;GAGG;AACH,oBAAY,kBAAkB;IAC5B,WAAW,oBAAoB;IAC/B,mBAAmB,4BAA4B;IAC/C,kBAAkB,2BAA2B;IAC7C,oBAAoB,6BAA6B;IACjD,oBAAoB,6BAA6B;IACjD,sBAAsB,+BAA+B;CACtD;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,IAAI,EAAE,kBAAkB;aACxB,KAAK,EAAE,MAAM;aACb,KAAK,EAAE,OAAO;gBAFd,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EAC9B,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAmBzD;AAmLD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,UAAU,EAAE,MAAM,GACjB,IAAI,CAwDN;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAoCpB"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/core/isg/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,sBAAsB,CAAC;AAEjE;;;GAGG;AACH,oBAAY,kBAAkB;IAC5B,WAAW,oBAAoB;IAC/B,mBAAmB,4BAA4B;IAC/C,kBAAkB,2BAA2B;IAC7C,oBAAoB,6BAA6B;IACjD,oBAAoB,6BAA6B;IACjD,sBAAsB,+BAA+B;CACtD;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,IAAI,EAAE,kBAAkB;aACxB,KAAK,EAAE,MAAM;aACb,KAAK,EAAE,OAAO;gBAFd,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EAC9B,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAmBzD;AAmLD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,UAAU,EAAE,MAAM,GACjB,IAAI,CAwDN;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAoCpB"}

package/dist/core/markdown.d.ts

@@ -1,5 +1,5 @@
 import MarkdownIt from 'markdown-it';
-import type { StatiConfig } from '../types.js';
+import type { StatiConfig } from '../types/index.js';
 /**
  * Creates and configures a MarkdownIt processor based on the provided configuration.
  * Supports both plugin array format and configure function format.

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;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAuCtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,MAAM,CAEtE"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAuCtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,MAAM,CAEtE"}

package/dist/core/navigation.d.ts

@@ -1,4 +1,4 @@
-import type { PageModel, NavNode } from '../types.js';
+import type { PageModel, NavNode } from '../types/index.js';
 /**
  * Builds a hierarchical navigation structure from pages.
  * Groups pages by directory structure and sorts them appropriately.

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

@@ -1 +1 @@
-{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/core/navigation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,CAyC7D"}
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/core/navigation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,CAyC7D"}

package/dist/core/preview.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '../types/index.js';
+export interface PreviewServerOptions {
+    port?: number;
+    host?: string;
+    open?: boolean;
+    configPath?: string;
+    logger?: Logger;
+}
+export interface PreviewServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    url: string;
+}
+/**
+ * Creates a preview server that serves the built site from the dist directory
+ * without live reload functionality, perfect for previewing the production build.
+ */
+export declare function createPreviewServer(options?: PreviewServerOptions): Promise<PreviewServer>;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/core/preview.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD,MAAM,WAAW,oBAAoB;IACnC,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,aAAa;IAC5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAyBD;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,aAAa,CAAC,CA+JxB"}

package/dist/core/preview.js

@@ -0,0 +1,163 @@
+import { createServer } from 'http';
+import { join, extname } from 'path';
+import { readFile, stat } from 'fs/promises';
+import { loadConfig } from '../config/loader.js';
+import { resolveDevPaths } from './utils/paths.js';
+import { DEFAULT_DEV_PORT, DEFAULT_DEV_HOST } from '../constants.js';
+/**
+ * Loads and validates configuration for the preview server.
+ */
+async function loadPreviewConfig(configPath, logger) {
+    try {
+        if (configPath) {
+            logger.info?.(`Loading config from: ${configPath}`);
+        }
+        const config = await loadConfig(process.cwd());
+        const { outDir } = resolveDevPaths(config);
+        return { outDir };
+    }
+    catch (error) {
+        logger.error?.(`Failed to load config: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+/**
+ * Creates a preview server that serves the built site from the dist directory
+ * without live reload functionality, perfect for previewing the production build.
+ */
+export async function createPreviewServer(options = {}) {
+    const { port = DEFAULT_DEV_PORT, host = DEFAULT_DEV_HOST, open = false, configPath, logger = {
+        info: () => { },
+        success: () => { },
+        error: (msg) => console.error(msg),
+        warning: (msg) => console.warn(msg),
+        building: () => { },
+        processing: () => { },
+        stats: () => { },
+    }, } = options;
+    const url = `http://${host}:${port}`;
+    let httpServer = null;
+    // Load configuration
+    const { outDir } = await loadPreviewConfig(configPath, logger);
+    /**
+     * Gets MIME type for a file based on its extension
+     */
+    function getMimeType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.html': 'text/html',
+            '.js': 'application/javascript',
+            '.css': 'text/css',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+            '.webp': 'image/webp',
+            '.woff': 'font/woff',
+            '.woff2': 'font/woff2',
+            '.ttf': 'font/ttf',
+            '.eot': 'application/vnd.ms-fontobject',
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+    /**
+     * Serves files from the dist directory
+     */
+    async function serveFile(requestPath) {
+        let filePath = join(outDir, requestPath === '/' ? 'index.html' : requestPath);
+        try {
+            const stats = await stat(filePath);
+            if (stats.isDirectory()) {
+                // Try to serve index.html from directory
+                const indexPath = join(filePath, 'index.html');
+                try {
+                    await stat(indexPath);
+                    filePath = indexPath;
+                }
+                catch {
+                    return {
+                        content: '404 - Directory listing not available',
+                        mimeType: 'text/plain',
+                        statusCode: 404,
+                    };
+                }
+            }
+            const mimeType = getMimeType(filePath);
+            const content = await readFile(filePath);
+            // Unlike dev server, we don't inject live reload script in preview mode
+            return {
+                content,
+                mimeType,
+                statusCode: 200,
+            };
+        }
+        catch {
+            // File not found
+            return {
+                content: '404 - File not found',
+                mimeType: 'text/plain',
+                statusCode: 404,
+            };
+        }
+    }
+    const previewServer = {
+        url,
+        async start() {
+            // Create HTTP server
+            httpServer = createServer(async (req, res) => {
+                const requestPath = req.url || '/';
+                logger.processing?.(`${req.method} ${requestPath}`);
+                try {
+                    const { content, mimeType, statusCode } = await serveFile(requestPath);
+                    res.writeHead(statusCode, {
+                        'Content-Type': mimeType,
+                        'Access-Control-Allow-Origin': '*',
+                        'Cache-Control': 'public, max-age=31536000', // Better caching for production preview
+                    });
+                    res.end(content);
+                }
+                catch (error) {
+                    logger.error?.(`Server error: ${error instanceof Error ? error.message : String(error)}`);
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('500 - Internal Server Error');
+                }
+            });
+            // Start HTTP server
+            await new Promise((resolve, reject) => {
+                httpServer.listen(port, host, () => {
+                    resolve();
+                });
+                httpServer.on('error', (error) => {
+                    reject(error);
+                });
+            });
+            logger.success?.(`Preview server running at ${url}`);
+            logger.info?.(`\nServing from:`);
+            logger.info?.(`  📁 ${outDir}`);
+            // Open browser if requested
+            if (open) {
+                try {
+                    const { default: openBrowser } = await import('open');
+                    await openBrowser(url);
+                }
+                catch {
+                    logger.info?.('Could not open browser automatically');
+                }
+            }
+        },
+        async stop() {
+            if (httpServer) {
+                await new Promise((resolve) => {
+                    httpServer.close(() => {
+                        resolve();
+                    });
+                });
+                httpServer = null;
+            }
+        },
+    };
+    return previewServer;
+}

package/dist/core/templates.d.ts

@@ -1,5 +1,5 @@
 import { Eta } from 'eta';
-import type { StatiConfig, PageModel, NavNode } from '../types.js';
+import type { StatiConfig, PageModel, NavNode } from '../types/index.js';
 export declare function createTemplateEngine(config: StatiConfig): Eta;
 export declare function renderPage(page: PageModel, body: string, config: StatiConfig, eta: Eta, navigation?: NavNode[], allPages?: PageModel[]): Promise<string>;
 //# sourceMappingURL=templates.d.ts.map