@stati/core 1.3.2 → 1.5.0

package/README.md

@@ -1,6 +1,6 @@
 # @stati/core
 
-The core engine for Stati, a lightweight TypeScript static site generator built with Vite-inspired architecture.
+The core engine for Stati, a lightweight TypeScript static site generator built with modern architecture.
 
 ## Installation
 

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

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAQ7D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAmLD,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAqQxF"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAa7D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAoOD,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CA2XxF"}

package/dist/core/dev.js

@@ -1,13 +1,18 @@
 import { createServer } from 'http';
 import { join, extname } from 'path';
 import { posix } from 'path';
-import { readFile, stat } from 'fs/promises';
+import { readFile } from 'fs/promises';
 import { WebSocketServer } from 'ws';
 import chokidar from 'chokidar';
 import { build } from './build.js';
+import { invalidate } from './invalidate.js';
 import { loadConfig } from '../config/loader.js';
 import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
 import { resolveDevPaths, resolveCacheDir } from './utils/paths.js';
+import { resolvePrettyUrl } from './utils/server.js';
+import { createErrorOverlay, parseErrorDetails } from './utils/error-overlay.js';
+import { TemplateError } from './utils/template-errors.js';
+import { setEnv, getEnv } from '../env.js';
 import { DEFAULT_DEV_PORT, DEFAULT_DEV_HOST, TEMPLATE_EXTENSION } from '../constants.js';
 /**
  * Loads and validates configuration for the dev server.
@@ -32,24 +37,35 @@ async function loadDevConfig(configPath, logger) {
 /**
  * Performs an initial build to ensure dist/ exists
  */
-async function performInitialBuild(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...');
+        await invalidate();
         await build({
             logger,
             force: false,
             clean: false,
             ...(configPath && { configPath }),
         });
+        // Clear any previous errors on successful build
+        if (onError) {
+            onError(null);
+        }
     }
     catch (error) {
-        logger.error?.(`Initial build failed: ${error instanceof Error ? error.message : String(error)}`);
-        throw error;
+        const buildError = error instanceof Error ? error : new Error(String(error));
+        logger.error?.(`Initial build failed: ${buildError.message}`);
+        // Store the error for display in browser - DON'T clear it even if partial rebuild succeeds
+        onError?.(buildError);
+        // In development, don't throw - let the dev server start and show errors in browser
+        logger.warning?.('Dev server will start with build errors. Check browser for error overlay.');
     }
 }
 /**
  * Performs incremental rebuild when files change, using ISG logic for smart rebuilds
  */
-async function performIncrementalRebuild(changedPath, configPath, logger, wsServer, isBuildingRef) {
+async function performIncrementalRebuild(changedPath, configPath, logger, wsServer, isBuildingRef, onError) {
     if (isBuildingRef.value) {
         logger.info?.('Build in progress, skipping...');
         return;
@@ -84,6 +100,10 @@ async function performIncrementalRebuild(changedPath, configPath, logger, wsServ
                 ...(configPath && { configPath }),
             });
         }
+        // Clear any previous errors on successful build
+        if (onError) {
+            onError(null);
+        }
         // Notify all connected clients to reload
         if (wsServer) {
             wsServer.clients.forEach((client) => {
@@ -98,8 +118,13 @@ async function performIncrementalRebuild(changedPath, configPath, logger, wsServ
         logger.info?.(`⚡ ${relativePath} rebuilt 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: ${error instanceof Error ? error.message : String(error)}`);
+        logger.error?.(`❌ Rebuild failed after ${duration}ms: ${buildError.message}`);
+        // Store the error for display in browser
+        if (onError) {
+            onError(buildError);
+        }
     }
     finally {
         isBuildingRef.value = false;
@@ -125,8 +150,14 @@ async function handleTemplateChange(templatePath, configPath, logger) {
         }
         // Find pages that depend on this template
         const affectedPages = [];
+        const normalizedTemplatePath = posix.normalize(templatePath.replace(/\\/g, '/'));
         for (const [pagePath, entry] of Object.entries(cacheManifest.entries)) {
-            if (entry.deps.some((dep) => dep.includes(posix.normalize(templatePath.replace(/\\/g, '/'))))) {
+            if (entry.deps.some((dep) => {
+                const normalizedDep = posix.normalize(dep.replace(/\\/g, '/'));
+                // Use endsWith for more precise matching to avoid false positives
+                return (normalizedDep === normalizedTemplatePath ||
+                    normalizedDep.endsWith('/' + normalizedTemplatePath));
+            })) {
                 affectedPages.push(pagePath);
                 // Remove from cache to force rebuild
                 delete cacheManifest.entries[pagePath];
@@ -143,15 +174,31 @@ async function handleTemplateChange(templatePath, configPath, logger) {
                 ...(configPath && { configPath }),
             });
         }
+        else {
+            // If no affected pages were found but a template changed,
+            // force a full rebuild to ensure changes are reflected
+            // This can happen if dependency tracking missed something
+            await build({
+                logger,
+                force: true,
+                clean: false,
+                ...(configPath && { configPath }),
+            });
+        }
     }
-    catch {
-        // Fallback to full rebuild
-        await build({
-            logger,
-            force: false,
-            clean: false,
-            ...(configPath && { configPath }),
-        });
+    catch (_error) {
+        try {
+            // Fallback to full rebuild
+            await build({
+                logger,
+                force: false,
+                clean: false,
+                ...(configPath && { configPath }),
+            });
+        }
+        catch (fallbackError) {
+            throw fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError));
+        }
     }
 }
 export async function createDevServer(options = {}) {
@@ -164,9 +211,16 @@ export async function createDevServer(options = {}) {
         processing: (msg) => console.log(msg),
         stats: (msg) => console.log(msg),
     }, } = options;
+    setEnv('development');
     const url = `http://${host}:${port}`;
     let httpServer = null;
     let wsServer = null;
+    // Track build errors for display in browser
+    let lastBuildError = null;
+    // Function to set build errors for error overlay display
+    const setLastBuildError = (error) => {
+        lastBuildError = error;
+    };
     let watcher = null;
     const isBuildingRef = { value: false };
     // Load configuration
@@ -232,24 +286,90 @@ export async function createDevServer(options = {}) {
      * 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;
+        // Use the global build error
+        const errorToShow = lastBuildError;
+        // If there's a build error, show error overlay for HTML requests
+        if (errorToShow &&
+            (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.'))) {
+            let errorDetails;
+            // Use enhanced error details for TemplateError instances
+            if (errorToShow instanceof TemplateError) {
+                errorDetails = await errorToShow.toErrorDetails();
+            }
+            else {
+                // Determine error type based on error message
+                const message = errorToShow.message.toLowerCase();
+                const name = errorToShow.name ? errorToShow.name.toLowerCase() : '';
+                const errorType = message.includes('template') ||
+                    message.includes('eta') ||
+                    message.includes('layout') ||
+                    name.includes('template')
+                    ? 'template'
+                    : message.includes('front-matter') ||
+                        message.includes('yaml') ||
+                        name.includes('yaml') ||
+                        name.includes('yamlexception')
+                        ? 'markdown'
+                        : message.includes('config') || name.includes('config')
+                            ? 'config'
+                            : 'build';
+                errorDetails = parseErrorDetails(errorToShow, errorType);
+            }
+            const errorHtml = createErrorOverlay(errorDetails, requestPath);
+            return {
+                content: errorHtml,
+                mimeType: 'text/html',
+                statusCode: 500,
+            };
+        }
+        const originalFilePath = join(outDir, requestPath === '/' ? 'index.html' : requestPath);
+        // Use the shared pretty URL resolver
+        const { filePath, found } = await resolvePrettyUrl(outDir, requestPath, originalFilePath);
+        if (!found || !filePath) {
+            // If we have a build error and this is an HTML request, show error overlay instead of 404
+            const errorToShow = lastBuildError;
+            if (errorToShow &&
+                (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.'))) {
+                // Use enhanced error details for TemplateError instances
+                let errorDetails;
+                if (errorToShow instanceof TemplateError) {
+                    errorDetails = await errorToShow.toErrorDetails();
                 }
-                catch {
-                    return {
-                        content: '404 - Directory listing not available',
-                        mimeType: 'text/plain',
-                        statusCode: 404,
-                    };
+                else {
+                    // Determine error type based on error message
+                    const message = errorToShow.message.toLowerCase();
+                    const name = errorToShow.name ? errorToShow.name.toLowerCase() : '';
+                    const errorType = message.includes('template') ||
+                        message.includes('eta') ||
+                        message.includes('layout') ||
+                        name.includes('template')
+                        ? 'template'
+                        : message.includes('front-matter') ||
+                            message.includes('yaml') ||
+                            name.includes('yaml') ||
+                            name.includes('yamlexception')
+                            ? 'markdown'
+                            : message.includes('config') || name.includes('config')
+                                ? 'config'
+                                : 'build';
+                    errorDetails = parseErrorDetails(errorToShow, errorType);
                 }
+                const errorHtml = createErrorOverlay(errorDetails, requestPath);
+                return {
+                    content: errorHtml,
+                    mimeType: 'text/html',
+                    statusCode: 500,
+                };
             }
+            return {
+                content: requestPath.endsWith('/')
+                    ? '404 - Directory listing not available'
+                    : '404 - File not found',
+                mimeType: 'text/plain',
+                statusCode: 404,
+            };
+        }
+        try {
             const mimeType = getMimeType(filePath);
             const content = await readFile(filePath);
             // Inject live reload script into HTML files
@@ -269,11 +389,11 @@ export async function createDevServer(options = {}) {
             };
         }
         catch {
-            // File not found
+            // This should rarely happen since resolvePrettyUrl already checked the file exists
             return {
-                content: '404 - File not found',
+                content: '500 - Error reading file',
                 mimeType: 'text/plain',
-                statusCode: 404,
+                statusCode: 500,
             };
         }
     }
@@ -281,7 +401,7 @@ export async function createDevServer(options = {}) {
         url,
         async start() {
             // Perform initial build
-            await performInitialBuild(configPath, logger);
+            await performInitialBuild(configPath, logger, setLastBuildError);
             // Create HTTP server
             httpServer = createServer(async (req, res) => {
                 const requestPath = req.url || '/';
@@ -306,17 +426,25 @@ export async function createDevServer(options = {}) {
                 }
             });
             // Create WebSocket server for live reload
-            wsServer = new WebSocketServer({
-                server: httpServer,
-                path: '/__ws',
-            });
-            wsServer.on('connection', (ws) => {
-                logger.info?.('Browser connected for live reload');
-                const websocket = ws;
-                websocket.on('close', () => {
-                    logger.info?.('Browser disconnected from live reload');
-                });
-            });
+            if (getEnv() !== 'test') {
+                try {
+                    wsServer = new WebSocketServer({
+                        server: httpServer,
+                        path: '/__ws',
+                    });
+                    wsServer.on('connection', (ws) => {
+                        logger.info?.('Browser connected for live reload');
+                        const websocket = ws;
+                        websocket.on('close', () => {
+                            logger.info?.('Browser disconnected from live reload');
+                        });
+                    });
+                }
+                catch (_error) {
+                    logger.warning?.('WebSocket server creation failed, live reload will not be available');
+                    wsServer = null;
+                }
+            }
             // Start HTTP server
             await new Promise((resolve, reject) => {
                 httpServer.listen(port, host, () => {
@@ -334,13 +462,13 @@ export async function createDevServer(options = {}) {
                 ignoreInitial: true,
             });
             watcher.on('change', (path) => {
-                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef);
+                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef, setLastBuildError);
             });
             watcher.on('add', (path) => {
-                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef);
+                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef, setLastBuildError);
             });
             watcher.on('unlink', (path) => {
-                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef);
+                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef, setLastBuildError);
             });
             logger.success?.(`Dev server running at ${url}`);
             logger.info?.(`\nServing from:`);

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":"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"}
+{"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,CAiBhG;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

@@ -35,7 +35,19 @@ function createSha256Hash(data) {
  */
 export function computeContentHash(content, frontMatter) {
     // Hash the front matter (sorted for consistency)
-    const sortedFrontMatter = JSON.stringify(frontMatter, Object.keys(frontMatter).sort());
+    // Note: We need to sort keys at all levels, not just top level
+    const sortKeys = (obj) => {
+        if (obj === null || typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj))
+            return obj.map(sortKeys);
+        const sorted = {};
+        for (const key of Object.keys(obj).sort()) {
+            sorted[key] = sortKeys(obj[key]);
+        }
+        return sorted;
+    };
+    const sortedFrontMatter = JSON.stringify(sortKeys(frontMatter));
     return createSha256Hash([content, sortedFrontMatter]);
 }
 /**

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,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"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,aAAa,CAAC;AAIrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAmBrD;;;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/markdown.js

@@ -1,4 +1,23 @@
 import MarkdownIt from 'markdown-it';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import path from 'path';
+/**
+ * Load a markdown plugin, trying different resolution strategies
+ */
+async function loadMarkdownPlugin(pluginName) {
+    const fullPluginName = `markdown-it-${pluginName}`;
+    // Try importing from current working directory first (for projects using Stati)
+    try {
+        const require = createRequire(pathToFileURL(path.resolve(process.cwd(), 'package.json')));
+        const pluginPath = require.resolve(fullPluginName);
+        return await import(pathToFileURL(pluginPath).href);
+    }
+    catch {
+        // Fallback to standard resolution (for core package dependencies)
+        return await import(fullPluginName);
+    }
+}
 /**
  * Creates and configures a MarkdownIt processor based on the provided configuration.
  * Supports both plugin array format and configure function format.
@@ -15,7 +34,7 @@ export async function createMarkdownProcessor(config) {
             if (typeof plugin === 'string') {
                 // Plugin name only
                 try {
-                    const pluginModule = await import(`markdown-it-${plugin}`);
+                    const pluginModule = await loadMarkdownPlugin(plugin);
                     const pluginFunction = pluginModule.default || pluginModule;
                     md.use(pluginFunction);
                 }
@@ -27,7 +46,7 @@ export async function createMarkdownProcessor(config) {
                 // Plugin name with options [name, options]
                 const [pluginName, options] = plugin;
                 try {
-                    const pluginModule = await import(`markdown-it-${pluginName}`);
+                    const pluginModule = await loadMarkdownPlugin(pluginName);
                     const pluginFunction = pluginModule.default || pluginModule;
                     md.use(pluginFunction, options);
                 }

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;AAMhD,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,CA2JxB"}

package/dist/core/preview.js

@@ -0,0 +1,159 @@
+import { createServer } from 'http';
+import { join, extname } from 'path';
+import { readFile } from 'fs/promises';
+import { loadConfig } from '../config/loader.js';
+import { resolveDevPaths } from './utils/paths.js';
+import { resolvePrettyUrl } from './utils/server.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) {
+        const originalFilePath = join(outDir, requestPath === '/' ? 'index.html' : requestPath);
+        // Use the shared pretty URL resolver
+        const { filePath, found } = await resolvePrettyUrl(outDir, requestPath, originalFilePath);
+        if (!found || !filePath) {
+            return {
+                content: requestPath.endsWith('/')
+                    ? '404 - Directory listing not available'
+                    : '404 - File not found',
+                mimeType: 'text/plain',
+                statusCode: 404,
+            };
+        }
+        try {
+            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 {
+            // This should rarely happen since resolvePrettyUrl already checked the file exists
+            return {
+                content: '500 - Error reading file',
+                mimeType: 'text/plain',
+                statusCode: 500,
+            };
+        }
+    }
+    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.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/core/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAG1B,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAkB,MAAM,mBAAmB,CAAC;AAiLzF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CAS7D;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,OAAO,EAAE,EACtB,QAAQ,CAAC,EAAE,SAAS,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC,CAkEjB"}
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/core/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAG1B,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAkB,MAAM,mBAAmB,CAAC;AAqLzF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CAW7D;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,OAAO,EAAE,EACtB,QAAQ,CAAC,EAAE,SAAS,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC,CA0JjB"}