@stati/core 1.0.0 → 1.2.0

package/README.md

@@ -0,0 +1,217 @@
+# @stati/core
+
+The core engine for Stati, a lightweight TypeScript static site generator built with Vite-inspired architecture.
+
+## Installation
+
+```bash
+npm install @stati/core
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { build, createDevServer, defineConfig } from '@stati/core';
+
+// Define configuration
+const config = defineConfig({
+  site: './site',
+  output: './dist',
+  public: './public',
+});
+
+// Build site
+await build(config);
+
+// Or start development server
+const server = await createDevServer(config, {
+  port: 3000,
+  open: true,
+});
+```
+
+### Configuration
+
+```typescript
+import { defineConfig } from '@stati/core/config';
+
+export default defineConfig({
+  // Site source directory
+  site: './site',
+
+  // Output directory for built site
+  output: './dist',
+
+  // Static assets directory
+  public: './public',
+
+  // Site metadata
+  meta: {
+    title: 'My Site',
+    description: 'A great static site',
+    url: 'https://example.com',
+  },
+
+  // Markdown configuration
+  markdown: {
+    plugins: ['markdown-it-anchor'],
+    options: {
+      html: true,
+      linkify: true,
+      typographer: true,
+    },
+  },
+
+  // Template configuration
+  templates: {
+    engine: 'eta',
+    options: {
+      views: './site',
+      cache: true,
+    },
+  },
+});
+```
+
+## API
+
+### Core Functions
+
+#### `build(options: BuildOptions): Promise<void>`
+
+Build a static site.
+
+```typescript
+import { build } from '@stati/core';
+
+await build({
+  config: './stati.config.js',
+  force: false,
+  clean: false,
+  includeDrafts: false,
+});
+```
+
+#### `createDevServer(config: StatiConfig, options: DevServerOptions): Promise<DevServer>`
+
+Create a development server with live reload.
+
+```typescript
+import { createDevServer } from '@stati/core';
+
+const server = await createDevServer(config, {
+  port: 3000,
+  open: true,
+});
+```
+
+#### `invalidate(query?: string): Promise<InvalidationResult>`
+
+Invalidate cache by tags, paths, patterns, or age.
+
+```typescript
+import { invalidate } from '@stati/core';
+
+// Invalidate by tag
+await invalidate('tag:blog');
+
+// Invalidate by path prefix
+await invalidate('path:/posts');
+
+// Invalidate by glob pattern
+await invalidate('glob:/blog/**');
+
+// Invalidate content younger than 3 months
+await invalidate('age:3months');
+
+// Multiple criteria (OR logic)
+await invalidate('tag:blog age:1month');
+
+// Clear entire cache
+await invalidate();
+```
+
+### Configuration
+
+#### `defineConfig(config: StatiConfig): StatiConfig`
+
+Define a type-safe configuration with full TypeScript support.
+
+```typescript
+import { defineConfig } from '@stati/core/config';
+
+export default defineConfig({
+  // Your configuration here
+});
+```
+
+## Types
+
+The package exports comprehensive TypeScript types:
+
+```typescript
+import type {
+  StatiConfig,
+  BuildOptions,
+  DevServerOptions,
+  InvalidateOptions,
+  Page,
+  Navigation,
+  MarkdownOptions,
+  TemplateOptions,
+} from '@stati/core/types';
+```
+
+## Features
+
+### Markdown Processing
+
+- **Front-matter support** with YAML, TOML, or JSON
+- **Plugin system** using markdown-it ecosystem
+- **Custom rendering** with configurable options
+- **Draft pages** with `draft: true` in front-matter
+
+### Template Engine
+
+- **Eta templates** with layouts and partials
+- **Template inheritance** with `layout` front-matter property
+- **Custom helpers** and filters
+- **Hot reload** during development
+
+### Navigation System
+
+- **Automatic hierarchy** based on filesystem structure
+- **Breadcrumbs** and navigation trees
+- **Custom sorting** with `order` front-matter property
+- **Index pages** with special handling
+
+### Development Server
+
+- **Live reload** with WebSocket integration
+- **Hot rebuilding** on file changes
+- **Static asset serving** from public directory
+- **Error overlay** for development debugging
+
+### Caching & Performance
+
+- **Smart caching** based on file modification times
+- **Incremental builds** for faster rebuilds
+- **Tag-based invalidation** for selective cache clearing
+- **Memory optimization** for large sites
+
+## Architecture
+
+Stati Core is built with a modular architecture:
+
+- **Content processing** - Markdown parsing and front-matter extraction
+- **Template rendering** - Eta engine with layouts and partials
+- **Navigation building** - Automatic hierarchy generation
+- **Asset handling** - Static file copying and optimization
+- **Development server** - Live reload and hot rebuilding
+- **Build system** - Production optimization and output generation
+
+## License
+
+MIT

package/dist/config/loader.d.ts.map

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

package/dist/config/loader.js

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

package/dist/core/build.d.ts

@@ -1,4 +1,4 @@
-import type { BuildStats } from '../types.js';
+import type { BuildStats, Logger } from '../types.js';
 /**
  * Options for customizing the build process.
  *
@@ -8,7 +8,8 @@ import type { BuildStats } from '../types.js';
  *   force: true,        // Force rebuild of all pages
  *   clean: true,        // Clean output directory before build
  *   configPath: './custom.config.js',  // Custom config file path
- *   includeDrafts: true // Include draft pages in build
+ *   includeDrafts: true, // Include draft pages in build
+ *   version: '1.0.0'    // Version to display in build messages
  * };
  * ```
  */
@@ -21,10 +22,15 @@ export interface BuildOptions {
     configPath?: string;
     /** Include draft pages in the build */
     includeDrafts?: boolean;
+    /** Custom logger for build output */
+    logger?: Logger;
+    /** Version information to display in build messages */
+    version?: string;
 }
 /**
  * Builds the static site by processing content files and generating HTML pages.
  * This is the main entry point for Stati's build process.
+ * Uses build locking to prevent concurrent builds from corrupting cache.
  *
  * @param options - Build configuration options
  *
@@ -46,6 +52,7 @@ export interface BuildOptions {
  * @throws {Error} When configuration loading fails
  * @throws {Error} When content processing fails
  * @throws {Error} When template rendering fails
+ * @throws {Error} When build lock cannot be acquired
  */
 export declare function build(options?: BuildOptions): Promise<BuildStats>;
 //# sourceMappingURL=build.d.ts.map

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

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

package/dist/core/build.js

@@ -1,11 +1,15 @@
 import fse from 'fs-extra';
-const { ensureDir, writeFile, copy, remove, pathExists, stat, readdir } = fse;
-import { join, dirname } from 'path';
+const { ensureDir, writeFile, remove, pathExists, stat, readdir, copyFile } = fse;
+import { join, dirname, relative } from 'path';
+import { posix } from 'path';
 import { loadConfig } from '../config/loader.js';
 import { loadContent } from './content.js';
 import { createMarkdownProcessor, renderMarkdown } from './markdown.js';
 import { createTemplateEngine, renderPage } from './templates.js';
 import { buildNavigation } from './navigation.js';
+import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
+import { shouldRebuildPage, createCacheEntry, updateCacheEntry } from './isg/builder.js';
+import { withBuildLock } from './isg/build-lock.js';
 /**
  * Recursively calculates the total size of a directory in bytes.
  * Used for build statistics.
@@ -32,31 +36,59 @@ async function getDirectorySize(dirPath) {
     return totalSize;
 }
 /**
- * Counts the number of files in a directory recursively.
- * Used for build statistics.
+ * Recursively copies static assets from source to destination directory
+ * while logging each file being copied.
  *
- * @param dirPath - Path to the directory
- * @returns Total number of files
+ * @param sourceDir - Source directory containing static assets
+ * @param destDir - Destination directory to copy assets to
+ * @param logger - Logger instance for output
+ * @param basePath - Base path for relative path calculation (for recursion)
+ * @returns Total number of files copied
  */
-async function countFilesInDirectory(dirPath) {
-    if (!(await pathExists(dirPath))) {
+async function copyStaticAssetsWithLogging(sourceDir, destDir, logger, basePath = '') {
+    let filesCopied = 0;
+    if (!(await pathExists(sourceDir))) {
         return 0;
     }
-    let fileCount = 0;
-    const items = await readdir(dirPath, { withFileTypes: true });
+    const items = await readdir(sourceDir, { withFileTypes: true });
     for (const item of items) {
-        const itemPath = join(dirPath, item.name);
+        const sourcePath = join(sourceDir, item.name);
+        const destPath = join(destDir, basePath, item.name);
+        const relativePath = posix.normalize(posix.join(basePath, item.name));
         if (item.isDirectory()) {
-            fileCount += await countFilesInDirectory(itemPath);
+            // Recursively copy directories
+            await ensureDir(destPath);
+            filesCopied += await copyStaticAssetsWithLogging(sourcePath, destPath, logger, relativePath);
         }
         else {
-            fileCount++;
+            // Copy individual files
+            await ensureDir(dirname(destPath));
+            await copyFile(sourcePath, destPath);
+            if (logger.file) {
+                logger.file('copy', relativePath);
+            }
+            else {
+                logger.processing(`📄 ${relativePath}`);
+            }
+            filesCopied++;
         }
     }
-    return fileCount;
+    return filesCopied;
 }
 /**
- * Formats build statistics for display.
+ * Default console logger implementation.
+ */
+const defaultLogger = {
+    info: (message) => console.log(message),
+    success: (message) => console.log(message),
+    warning: (message) => console.warn(message),
+    error: (message) => console.error(message),
+    building: (message) => console.log(message),
+    processing: (message) => console.log(message),
+    stats: (message) => console.log(message),
+};
+/**
+ * Formats build statistics for display with prettier output.
  *
  * @param stats - Build statistics to format
  * @returns Formatted statistics string
@@ -64,22 +96,25 @@ async function countFilesInDirectory(dirPath) {
 function formatBuildStats(stats) {
     const sizeKB = (stats.outputSizeBytes / 1024).toFixed(1);
     const timeSeconds = (stats.buildTimeMs / 1000).toFixed(2);
-    let output = `📊 Build Statistics:
-  ⏱️  Build time: ${timeSeconds}s
-  📄 Pages built: ${stats.totalPages}
-  📦 Assets copied: ${stats.assetsCount}
-  💾 Output size: ${sizeKB} KB`;
+    let output = `Build Statistics:
+┌─────────────────────────────────────────┐
+│  Build time: ${timeSeconds}s`.padEnd(41) + '│';
+    output += `\n│  📄 Pages built: ${stats.totalPages}`.padEnd(42) + '│';
+    output += `\n│  📦 Assets copied: ${stats.assetsCount}`.padEnd(42) + '│';
+    output += `\n│  Output size: ${sizeKB} KB`.padEnd(42) + '│';
     if (stats.cacheHits !== undefined && stats.cacheMisses !== undefined) {
         const totalCacheRequests = stats.cacheHits + stats.cacheMisses;
         const hitRate = totalCacheRequests > 0 ? ((stats.cacheHits / totalCacheRequests) * 100).toFixed(1) : '0';
-        output += `
-  🎯 Cache hits: ${stats.cacheHits}/${totalCacheRequests} (${hitRate}%)`;
+        output +=
+            `\n│  Cache hits: ${stats.cacheHits}/${totalCacheRequests} (${hitRate}%)`.padEnd(42) + '│';
     }
+    output += '\n└─────────────────────────────────────────┘';
     return output;
 }
 /**
  * Builds the static site by processing content files and generating HTML pages.
  * This is the main entry point for Stati's build process.
+ * Uses build locking to prevent concurrent builds from corrupting cache.
  *
  * @param options - Build configuration options
  *
@@ -101,29 +136,64 @@ function formatBuildStats(stats) {
  * @throws {Error} When configuration loading fails
  * @throws {Error} When content processing fails
  * @throws {Error} When template rendering fails
+ * @throws {Error} When build lock cannot be acquired
  */
 export async function build(options = {}) {
+    const cacheDir = join(process.cwd(), '.stati');
+    // Use build lock to prevent concurrent builds, with force option to override
+    return await withBuildLock(cacheDir, () => buildInternal(options), {
+        force: Boolean(options.force || options.clean), // Allow force if user explicitly requests it
+        timeout: 60000, // 1 minute timeout
+    });
+}
+/**
+ * Internal build implementation without locking.
+ * Separated for cleaner error handling and testing.
+ */
+async function buildInternal(options = {}) {
     const buildStartTime = Date.now();
-    console.log('🏗️  Building site...');
+    const logger = options.logger || defaultLogger;
+    logger.building('Building your site...');
+    console.log(); // Add spacing after build start
     // Load configuration
     const config = await loadConfig(options.configPath ? dirname(options.configPath) : process.cwd());
     const outDir = join(process.cwd(), config.outDir);
     // Create .stati cache directory
     const cacheDir = join(process.cwd(), '.stati');
     await ensureDir(cacheDir);
+    // Load cache manifest for ISG
+    let cacheManifest = await loadCacheManifest(cacheDir);
+    // If no cache manifest exists, create an empty one
+    if (!cacheManifest) {
+        cacheManifest = {
+            entries: {},
+        };
+    }
+    // At this point cacheManifest is guaranteed to be non-null
+    const manifest = cacheManifest;
+    // Initialize cache stats
+    let cacheHits = 0;
+    let cacheMisses = 0;
     // Clean output directory if requested
     if (options.clean) {
-        console.log('🧹 Cleaning output directory...');
+        logger.info('Cleaning output directory...');
         await remove(outDir);
     }
     await ensureDir(outDir);
     // Load all content
     const pages = await loadContent(config, options.includeDrafts);
-    console.log(`📄 Found ${pages.length} pages`);
+    logger.info(`📄 Found ${pages.length} pages`);
     // Build navigation from pages
+    console.log(); // Add spacing before navigation step
+    if (logger.step) {
+        logger.step(1, 3, 'Building navigation');
+    }
     const navigation = buildNavigation(pages);
-    console.log(`🧭 Built navigation with ${navigation.length} top-level items`);
-    // Create processors
+    logger.info(`Built navigation with ${navigation.length} top-level items`);
+    // Display navigation tree if the logger supports it
+    if (logger.navigationTree) {
+        logger.navigationTree(navigation);
+    } // Create processors
     const md = await createMarkdownProcessor(config);
     const eta = createTemplateEngine(config);
     // Build context
@@ -132,18 +202,28 @@ export async function build(options = {}) {
     if (config.hooks?.beforeAll) {
         await config.hooks.beforeAll(buildContext);
     }
-    // Render each page
-    for (const page of pages) {
-        console.log(`  Building ${page.url}`);
-        // Run beforeRender hook
-        if (config.hooks?.beforeRender) {
-            await config.hooks.beforeRender({ page, config });
+    // Render each page with tree-based progress tracking and ISG
+    if (logger.step) {
+        logger.step(2, 3, 'Rendering pages');
+    }
+    // Initialize rendering tree
+    if (logger.startRenderingTree) {
+        logger.startRenderingTree('Page Rendering Process');
+    }
+    const buildTime = new Date();
+    for (let i = 0; i < pages.length; i++) {
+        const page = pages[i];
+        if (!page)
+            continue; // Safety check
+        const pageId = `page-${i}`;
+        // Add page to rendering tree
+        if (logger.addTreeNode) {
+            logger.addTreeNode('root', pageId, page.url, 'running', { url: page.url });
         }
-        // Render markdown to HTML
-        const htmlContent = renderMarkdown(page.content, md);
-        // Render with template
-        const finalHtml = await renderPage(page, htmlContent, config, eta, navigation, pages);
-        // Determine output path - fix the logic here
+        else {
+            logger.processing(`Checking ${page.url}`);
+        }
+        // Determine output path
         let outputPath;
         if (page.url === '/') {
             outputPath = join(outDir, 'index.html');
@@ -154,21 +234,89 @@ export async function build(options = {}) {
         else {
             outputPath = join(outDir, `${page.url}.html`);
         }
+        // Get cache key (use output path relative to outDir)
+        const relativePath = relative(outDir, outputPath).replace(/\\/g, '/');
+        const cacheKey = relativePath.startsWith('/') ? relativePath : `/${relativePath}`;
+        const existingEntry = manifest.entries[cacheKey];
+        // Check if we should rebuild this page (considering ISG logic)
+        const shouldRebuild = options.force || (await shouldRebuildPage(page, existingEntry, config, buildTime));
+        if (!shouldRebuild) {
+            // Cache hit - skip rendering
+            cacheHits++;
+            if (logger.updateTreeNode) {
+                logger.updateTreeNode(pageId, 'cached', { cacheHit: true, url: page.url });
+            }
+            else {
+                logger.processing(`📋 Cached ${page.url}`);
+            }
+            continue;
+        }
+        // Cache miss - need to rebuild
+        cacheMisses++;
+        const startTime = Date.now();
+        // Add rendering substeps to tree
+        const markdownId = `${pageId}-markdown`;
+        const templateId = `${pageId}-template`;
+        if (logger.addTreeNode) {
+            logger.addTreeNode(pageId, markdownId, 'Processing Markdown', 'running');
+            logger.addTreeNode(pageId, templateId, 'Applying Template', 'pending');
+        }
+        // Run beforeRender hook
+        if (config.hooks?.beforeRender) {
+            await config.hooks.beforeRender({ page, config });
+        }
+        // Render markdown to HTML
+        const htmlContent = renderMarkdown(page.content, md);
+        if (logger.updateTreeNode) {
+            logger.updateTreeNode(markdownId, 'completed');
+            logger.updateTreeNode(templateId, 'running');
+        }
+        // Render with template
+        const finalHtml = await renderPage(page, htmlContent, config, eta, navigation, pages);
+        const renderTime = Date.now() - startTime;
+        if (logger.updateTreeNode) {
+            logger.updateTreeNode(templateId, 'completed');
+            logger.updateTreeNode(pageId, 'completed', {
+                timing: renderTime,
+                url: page.url,
+            });
+        }
         // Ensure directory exists and write file
         await ensureDir(dirname(outputPath));
         await writeFile(outputPath, finalHtml, 'utf-8');
+        // Update cache manifest
+        if (existingEntry) {
+            manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, buildTime);
+        }
+        else {
+            manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime);
+        }
         // Run afterRender hook
         if (config.hooks?.afterRender) {
             await config.hooks.afterRender({ page, config });
         }
     }
+    // Display final rendering tree and clear it
+    if (logger.showRenderingTree) {
+        console.log(); // Add spacing
+        logger.showRenderingTree();
+        if (logger.clearRenderingTree) {
+            logger.clearRenderingTree();
+        }
+    }
+    // Save updated cache manifest
+    await saveCacheManifest(cacheDir, manifest);
     // Copy static assets and count them
     let assetsCount = 0;
     const staticDir = join(process.cwd(), config.staticDir);
     if (await pathExists(staticDir)) {
-        await copy(staticDir, outDir, { overwrite: true });
-        assetsCount = await countFilesInDirectory(staticDir);
-        console.log(`📦 Copied ${assetsCount} static assets`);
+        console.log(); // Add spacing before asset copying
+        if (logger.step) {
+            logger.step(3, 3, 'Copying static assets');
+        }
+        logger.info(`Copying static assets from ${config.staticDir}`);
+        assetsCount = await copyStaticAssetsWithLogging(staticDir, outDir, logger);
+        logger.info(`Copied ${assetsCount} static assets`);
     }
     // Run afterAll hook
     if (config.hooks?.afterAll) {
@@ -181,11 +329,17 @@ export async function build(options = {}) {
         assetsCount,
         buildTimeMs: buildEndTime - buildStartTime,
         outputSizeBytes: await getDirectorySize(outDir),
-        // Cache stats would be populated here when caching is implemented
-        cacheHits: 0,
-        cacheMisses: 0,
+        // Include ISG cache statistics
+        cacheHits,
+        cacheMisses,
     };
-    console.log('✅ Build complete!');
-    console.log(formatBuildStats(buildStats));
+    console.log(); // Add spacing before statistics
+    // Use table format if available, otherwise fall back to formatted string
+    if (logger.statsTable) {
+        logger.statsTable(buildStats);
+    }
+    else {
+        logger.stats(formatBuildStats(buildStats));
+    }
     return buildStats;
 }

package/dist/core/dev.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from '../types.js';
+export interface DevServerOptions {
+    port?: number;
+    host?: string;
+    open?: boolean;
+    configPath?: string;
+    logger?: Logger;
+}
+export interface DevServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    url: string;
+}
+/**
+ * Creates and configures a development server with live reload functionality.
+ *
+ * @param options - Development server configuration options
+ * @returns Promise resolving to a DevServer instance
+ */
+export declare function createDevServer(options?: DevServerOptions): Promise<DevServer>;
+//# sourceMappingURL=dev.d.ts.map