bertui 1.1.7 → 1.1.9

package/README.md

@@ -13,7 +13,7 @@ Zero configuration. 494ms dev server. 265ms builds. Perfect SEO with Server Isla
 [![Rust](https://img.shields.io/badge/optimizer-Rust-WASM-orange)](https://www.rust-lang.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-```bash
+
 # One command. Zero config. Instant speed. 78% smaller images.
 bunx create-bertui my-app && cd my-app && bun run dev
 
@@ -106,13 +106,13 @@ export default function About() {
 
 At build time:
 
-    ✅ Generates static HTML for instant loading
+  ✅ Generates static HTML for instant loading
 
-    ✅ Auto-adds to sitemap.xml
+  ✅ Auto-adds to sitemap.xml
 
-    ✅ Perfect SEO without SSR complexity
+  ✅ Perfect SEO without SSR complexity
 
-    ✅ Still builds in 265ms
+  ✅ Still builds in 265ms
 
 🦀 Image Optimization (Just Works)
 
@@ -241,17 +241,17 @@ Rust Required ❌ NO  N/A N/A N/A
 
 Future packages (in development):
 
-    🔄 bertui-elysia - Full-stack addon (API routes, auth, database)
+  🔄 bertui-elysia - Full-stack addon (API routes, auth, database)
 
-    🎨 bertui-animation - GPU-accelerated animations (Zig)
+  🎨 bertui-animation - GPU-accelerated animations (Zig)
 
-    📊 bertui-charts - High-performance charts (Rust)
+  📊 bertui-charts - High-performance charts (Rust)
 
 🙏 Credits
 
-    Runtime: Bun - The fastest JavaScript runtime
+  Runtime: Bun - The fastest JavaScript runtime
 
-    Server: Elysia - Fast and elegant web framework
+  Server: Elysia - Fast and elegant web framework
 
     CSS: LightningCSS - Lightning-fast CSS processing
 

package/index.js

@@ -1,44 +1,61 @@
-// bertui/src/index.js - ONE EXPORT FILE TO RULE THEM ALL
+// ============================================
+// FILE: bertui/index.js (Located in root)
+// ============================================
 
 // Compiler
-export { compileProject } from './client/compiler.js';
-export { compileForBuild } from './build/compiler/index.js';
-export { discoverRoutes } from './build/compiler/route-discoverer.js';
+export { compileProject, compileFile } from './src/client/compiler.js';
+export { compileForBuild } from './src/build/compiler/index.js';
+export { discoverRoutes } from './src/build/compiler/route-discoverer.js';
 
 // HMR
-export { hmr } from './client/hmr-runtime.js';
+export { hmr } from './src/client/hmr-runtime.js';
 
-// Image Optimizer - RUST WASM (no Rust for users)
+// Image Optimizer
 export { 
   optimizeImage, 
   optimizeImagesBatch, 
   hasWasm, 
   version as optimizerVersion 
-} from './image-optimizer/index.js';
+} from './src/image-optimizer/index.js';
 
 // Build
-export { buildProduction } from './build.js';
-export { optimizeImages } from './build/image-optimizer.js';
+export { buildProduction } from './src/build.js';
+export { optimizeImages } from './src/build/image-optimizer.js';
 
 // Router
-export { Router, Link, useRouter } from './router/index.js';
-export { SSRRouter } from './router/SSRRouter.jsx';
+export { Router, Link, useRouter } from './src/router/index.js';
+export { SSRRouter } from './src/router/SSRRouter.js';
 
 // Config
-export { loadConfig, defaultConfig } from './config/index.js';
+export { loadConfig, defaultConfig } from './src/config/index.js';
 
 // Logger
-export { default as logger } from './logger/logger.js';
+export { default as logger } from './src/logger/logger.js';
 
-// CLI (backward compatibility)
-export { program } from './cli.js';
+// CLI
+export { program } from './src/cli.js';
 
 // Version
 export const version = '1.2.0';
 
+// Import for default export
+import { compileProject, compileFile } from './src/client/compiler.js';
+import { compileForBuild } from './src/build/compiler/index.js';
+import { discoverRoutes } from './src/build/compiler/route-discoverer.js';
+import { hmr } from './src/client/hmr-runtime.js';
+import { optimizeImage, optimizeImagesBatch } from './src/image-optimizer/index.js';
+import { optimizeImages } from './src/build/image-optimizer.js';
+import { buildProduction } from './src/build.js';
+import { Router, Link, useRouter } from './src/router/index.js';
+import { SSRRouter } from './src/router/SSRRouter.js';
+import { loadConfig, defaultConfig } from './src/config/index.js';
+import logger from './src/logger/logger.js';
+import { program } from './src/cli.js';
+
 // Default export
 export default {
   compileProject,
+  compileFile,
   compileForBuild,
   discoverRoutes,
   hmr,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bertui",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Lightning-fast React dev server powered by Bun - Now with Rust image optimization (WASM, no Rust required for users)",
   "type": "module",
   "main": "./index.js",
@@ -11,8 +11,8 @@
   "exports": {
     ".": {
       "types": "./types/index.d.ts",
-      "import": "./src/index.js",
-      "default": "./src/index.js"
+      "import": "./index.js",
+      "default": "./index.js"
     },
     "./hmr": {
       "import": "./src/client/hmr-runtime.js"
@@ -45,9 +45,11 @@
   "scripts": {
     "dev": "bun bin/bertui.js dev",
     "build": "bun bin/bertui.js build",
+    "serve": "bun bin/bertui.js serve",
+    "preview": "bun bin/bertui.js serve --port 5000",
     "build:wasm": "cd src/image-optimizer-rust && wasm-pack build --target web --out-dir ../../dist/image-optimizer/wasm && bun run fix:wasm",
     "fix:wasm": "node scripts/fix-wasm-exports.js",
-    "prepublishOnly": "echo 'Skipping wasm build'",
+    "prepublishOnly": "echo 'Note: Ensure WASM is built via build:wasm before publishing'",
     "test": "cd test-app && bun run dev"
   },
   "dependencies": {
@@ -59,7 +61,7 @@
   "peerDependencies": {
     "bun": ">=1.0.0",
     "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^19.2.3"
+    "react-dom": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "@types/react": "^18.2.0",
@@ -69,7 +71,8 @@
   },
   "optionalDependencies": {
     "@bertui/image-optimizer-wasm": "0.1.0",
-    "oxipng": "^8.0.0"
+    "oxipng": "^8.0.0",
+    "sass": "^1.69.5"
   },
   "keywords": [
     "react",
@@ -94,4 +97,4 @@
   "engines": {
     "bun": ">=1.0.0"
   }
-}
+}

package/src/build/processors/css-builder.js

@@ -1,102 +1,138 @@
-// bertui/src/build/processors/css-builder.js - SAFE VERSION
+// bertui/src/build/processors/css-builder.js - WITH SCSS + CACHING
 import { join } from 'path';
 import { existsSync, readdirSync, mkdirSync } from 'fs';
 import logger from '../../logger/logger.js';
+import { globalCache } from '../../utils/cache.js';
+import { minifyCSS, processSCSS } from '../../css/processor.js';
 
 export async function buildAllCSS(root, outDir) {
+  const startTime = process.hrtime.bigint();
+  
   const srcStylesDir = join(root, 'src', 'styles');
   const stylesOutDir = join(outDir, 'styles');
   
   mkdirSync(stylesOutDir, { recursive: true });
   
-  if (existsSync(srcStylesDir)) {
-    const cssFiles = readdirSync(srcStylesDir).filter(f => f.endsWith('.css'));
-    
-    if (cssFiles.length === 0) {
-      await Bun.write(join(stylesOutDir, 'bertui.min.css'), '/* No CSS */');
-      return;
-    }
-    
-    logger.info(`Processing ${cssFiles.length} CSS file(s)...`);
-    
-    let combinedCSS = '';
-    for (const cssFile of cssFiles) {
-      const srcPath = join(srcStylesDir, cssFile);
-      const file = Bun.file(srcPath);
-      const cssContent = await file.text();
-      combinedCSS += `/* ${cssFile} */\n${cssContent}\n\n`;
-    }
-    
-    const combinedPath = join(stylesOutDir, 'bertui.min.css');
-    
-    // ✅ SAFE: Try Lightning CSS, fallback to simple minification
-    try {
-      const minified = await minifyCSSSafe(combinedCSS);
-      await Bun.write(combinedPath, minified);
-      
-      const originalSize = Buffer.byteLength(combinedCSS);
-      const minifiedSize = Buffer.byteLength(minified);
-      const reduction = ((1 - minifiedSize / originalSize) * 100).toFixed(1);
-      
-      logger.success(`CSS minified: ${(originalSize/1024).toFixed(2)}KB → ${(minifiedSize/1024).toFixed(2)}KB (-${reduction}%)`);
-    } catch (error) {
-      logger.warn(`CSS minification failed: ${error.message}`);
-      logger.info('Falling back to unminified CSS...');
-      await Bun.write(combinedPath, combinedCSS);
-    }
-    
-    logger.success(`✅ Combined ${cssFiles.length} CSS files`);
-  } else {
-    // No styles directory, create empty CSS
+  // Check cache for entire CSS build
+  const cacheKey = `css-build:${root}:${Date.now()}`;
+  const cached = globalCache.get(cacheKey, { ttl: 1000 }); // 1 second cache
+  
+  if (cached) {
+    logger.info(`⚡ Using cached CSS (${cached.files} files)`);
+    await Bun.write(join(stylesOutDir, 'bertui.min.css'), cached.content);
+    return;
+  }
+  
+  if (!existsSync(srcStylesDir)) {
     await Bun.write(join(stylesOutDir, 'bertui.min.css'), '/* No custom styles */');
     logger.info('No styles directory found, created empty CSS');
+    return;
+  }
+  
+  // Process SCSS files first
+  await processSCSSDirectory(srcStylesDir, root);
+  
+  // Read all CSS files (including compiled SCSS)
+  const cssFiles = readdirSync(srcStylesDir).filter(f => f.endsWith('.css'));
+  
+  if (cssFiles.length === 0) {
+    await Bun.write(join(stylesOutDir, 'bertui.min.css'), '/* No CSS */');
+    return;
   }
+  
+  logger.info(`Processing ${cssFiles.length} CSS file(s)...`);
+  
+  let combinedCSS = '';
+  const fileContents = [];
+  
+  for (const cssFile of cssFiles) {
+    const srcPath = join(srcStylesDir, cssFile);
+    
+    // Use file cache
+    const fileBuffer = await globalCache.getFile(srcPath, { logSpeed: true });
+    if (fileBuffer) {
+      const content = fileBuffer.toString('utf-8');
+      fileContents.push({ filename: cssFile, content });
+      combinedCSS += `/* ${cssFile} */\n${content}\n\n`;
+    }
+  }
+  
+  const combinedPath = join(stylesOutDir, 'bertui.min.css');
+  
+  // Minify with caching
+  const minifyCacheKey = `minify:${Buffer.from(combinedCSS).length}:${combinedCSS.substring(0, 100)}`;
+  let minified = globalCache.get(minifyCacheKey);
+  
+  if (!minified) {
+    minified = await minifyCSS(combinedCSS, {
+      filename: 'bertui.min.css',
+      sourceMap: false
+    });
+    globalCache.set(minifyCacheKey, minified, { ttl: 60000 }); // Cache for 60 seconds
+  }
+  
+  await Bun.write(combinedPath, minified);
+  
+  const originalSize = Buffer.byteLength(combinedCSS);
+  const minifiedSize = Buffer.byteLength(minified);
+  const reduction = ((1 - minifiedSize / originalSize) * 100).toFixed(1);
+  
+  const endTime = process.hrtime.bigint();
+  const duration = Number(endTime - startTime) / 1000; // Microseconds
+  
+  logger.success(`CSS optimized: ${(originalSize/1024).toFixed(2)}KB → ${(minifiedSize/1024).toFixed(2)}KB (-${reduction}%)`);
+  logger.info(`⚡ Processing time: ${duration.toFixed(3)}µs`);
+  
+  // Cache the final result
+  globalCache.set(cacheKey, {
+    files: cssFiles.length,
+    content: minified,
+    size: minifiedSize
+  }, { ttl: 5000 });
 }
 
-/**
- * Safe CSS minification with fallback
- */
-async function minifyCSSSafe(css) {
-  // Try Lightning CSS first
+// NEW: Process SCSS directory
+async function processSCSSDirectory(stylesDir, root) {
   try {
-    const { transform } = await import('lightningcss');
+    // Check if sass is installed
+    const sass = await import('sass').catch(() => null);
+    if (!sass) return;
     
-    const { code } = transform({
-      filename: 'styles.css',
-      code: Buffer.from(css),
-      minify: true,
-      sourceMap: false,
-      targets: {
-        chrome: 90 << 16,
-        firefox: 88 << 16,
-        safari: 14 << 16,
-        edge: 90 << 16
-      }
-    });
+    const files = readdirSync(stylesDir);
+    const scssFiles = files.filter(f => f.endsWith('.scss') || f.endsWith('.sass'));
     
-    return code.toString();
+    if (scssFiles.length === 0) return;
     
-  } catch (lightningError) {
-    logger.warn('Lightning CSS failed, using simple minification');
+    logger.info(`📝 Compiling ${scssFiles.length} SCSS files...`);
     
-    // Fallback: Simple manual minification
-    return simpleMinifyCSS(css);
+    for (const file of scssFiles) {
+      const srcPath = join(stylesDir, file);
+      const cssPath = join(stylesDir, file.replace(/\.(scss|sass)$/, '.css'));
+      
+      // Check cache
+      const fileBuffer = await globalCache.getFile(srcPath);
+      const cacheKey = `scss:${file}:${Buffer.from(fileBuffer).length}`;
+      const cached = globalCache.get(cacheKey);
+      
+      if (cached && existsSync(cssPath)) {
+        logger.debug(`⚡ Cached SCSS: ${file} → ${file.replace(/\.(scss|sass)$/, '.css')}`);
+        continue;
+      }
+      
+      const result = sass.compile(srcPath, {
+        style: 'expanded',
+        sourceMap: false,
+        loadPaths: [stylesDir, join(root, 'node_modules')]
+      });
+      
+      await Bun.write(cssPath, result.css);
+      globalCache.set(cacheKey, true, { ttl: 30000 });
+      
+      logger.debug(`   ${file} → ${file.replace(/\.(scss|sass)$/, '.css')}`);
+    }
+    
+    logger.success(`✅ SCSS compilation complete`);
+  } catch (error) {
+    logger.warn(`SCSS processing skipped: ${error.message}`);
   }
-}
-
-/**
- * Simple CSS minification without dependencies
- */
-function simpleMinifyCSS(css) {
-  return css
-    // Remove comments
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    // Remove extra whitespace
-    .replace(/\s+/g, ' ')
-    // Remove space around { } : ; ,
-    .replace(/\s*([{}:;,])\s*/g, '$1')
-    // Remove trailing semicolons before }
-    .replace(/;}/g, '}')
-    // Remove leading/trailing whitespace
-    .trim();
 }

package/src/build.js

@@ -1,8 +1,9 @@
-// bertui/src/build.js - CLEANED (No PageBuilder)
+// bertui/src/build.js - COMPLETE FIXED VERSION WITH PROPER EXIT
 import { join } from 'path';
 import { existsSync, mkdirSync, rmSync } from 'fs';
 import logger from './logger/logger.js';
 import { loadEnvVariables } from './utils/env.js';
+import { globalCache } from './utils/cache.js';
 
 import { compileForBuild } from './build/compiler/index.js';
 import { buildAllCSS } from './build/processors/css-builder.js';
@@ -22,12 +23,12 @@ export async function buildProduction(options = {}) {
   logger.bigLog('BUILDING WITH SERVER ISLANDS 🏝️', { color: 'green' });
   logger.info('🔥 OPTIONAL SERVER CONTENT - THE GAME CHANGER');
   
-  if (existsSync(buildDir)) rmSync(buildDir, { recursive: true });
-  if (existsSync(outDir)) rmSync(outDir, { recursive: true });
+  if (existsSync(buildDir)) rmSync(buildDir, { recursive: true, force: true });
+  if (existsSync(outDir)) rmSync(outDir, { recursive: true, force: true });
   mkdirSync(buildDir, { recursive: true });
   mkdirSync(outDir, { recursive: true });
   
-  const startTime = Date.now();
+  const startTime = process.hrtime.bigint(); // Microsecond precision
   
   try {
     logger.info('Step 0: Loading environment variables...');
@@ -48,53 +49,82 @@ export async function buildProduction(options = {}) {
       })));
     }
     
-    logger.info('Step 2: Combining CSS...');
+    logger.info('Step 2: Processing SCSS/SASS...');
+    await processSCSS(root, buildDir);
+    
+    logger.info('Step 3: Combining CSS...');
     await buildAllCSS(root, outDir);
     
-    logger.info('Step 3: Copying static assets...');
+    logger.info('Step 4: Copying static assets...');
     await copyAllStaticAssets(root, outDir);
     
-    logger.info('Step 4: Bundling JavaScript...');
+    logger.info('Step 5: Bundling JavaScript with Router...');
     const buildEntry = join(buildDir, 'main.js');
+    const routerPath = join(buildDir, 'router.js');
     
     if (!existsSync(buildEntry)) {
       logger.error('❌ main.js not found in build directory!');
       throw new Error('Build entry point missing');
     }
     
-    const result = await bundleJavaScript(buildEntry, outDir, envVars, buildDir);
+    const result = await bundleJavaScript(buildEntry, routerPath, outDir, envVars, buildDir);
     
-    logger.info('Step 5: Generating HTML with Server Islands...');
+    logger.info('Step 6: Generating HTML with Server Islands...');
     await generateProductionHTML(root, outDir, result, routes, serverIslands, config);
     
-    logger.info('Step 6: Generating sitemap.xml...');
+    logger.info('Step 7: Generating sitemap.xml...');
     await generateSitemap(routes, config, outDir);
     
-    logger.info('Step 7: Generating robots.txt...');
+    logger.info('Step 8: Generating robots.txt...');
     await generateRobots(config, outDir, routes);
     
-    if (existsSync(buildDir)) rmSync(buildDir, { recursive: true });
+    // Clean up build directory
+    if (existsSync(buildDir)) rmSync(buildDir, { recursive: true, force: true });
+    
+    const endTime = process.hrtime.bigint();
+    const durationMicro = Number(endTime - startTime) / 1000;
+    const durationMs = durationMicro / 1000;
     
-    const duration = Date.now() - startTime;
-    showBuildSummary(routes, serverIslands, clientRoutes, duration);
+    showBuildSummary(routes, serverIslands, clientRoutes, durationMs, durationMicro);
+    
+    // ✅ FIX: Force exit after successful build
+    // Small delay to ensure all logs are flushed
+    setTimeout(() => {
+      logger.info('✅ Build process complete, exiting...');
+      process.exit(0);
+    }, 100);
     
   } catch (error) {
     logger.error(`Build failed: ${error.message}`);
     if (error.stack) logger.error(error.stack);
-    if (existsSync(buildDir)) rmSync(buildDir, { recursive: true });
-    process.exit(1);
+    if (existsSync(buildDir)) rmSync(buildDir, { recursive: true, force: true });
+    
+    // ✅ FIX: Force exit with error code
+    setTimeout(() => {
+      process.exit(1);
+    }, 100);
   }
 }
 
-async function bundleJavaScript(buildEntry, outDir, envVars, buildDir) {
+async function bundleJavaScript(buildEntry, routerPath, outDir, envVars, buildDir) {
   try {
+    const hasRouter = existsSync(routerPath);
+    
     const originalCwd = process.cwd();
     process.chdir(buildDir);
     
     logger.info('🔧 Bundling with production JSX...');
     
+    const entrypoints = [buildEntry];
+    if (hasRouter) {
+      entrypoints.push(routerPath);
+      logger.success('✅ Router included in bundle');
+    }
+    
+    logger.info(`📦 Entry points: ${entrypoints.map(e => e.split('/').pop()).join(', ')}`);
+    
     const result = await Bun.build({
-      entrypoints: [buildEntry],
+      entrypoints,
       outdir: join(outDir, 'assets'),
       target: 'browser',
       minify: true,
@@ -129,16 +159,38 @@ async function bundleJavaScript(buildEntry, outDir, envVars, buildDir) {
           if (log.position) {
             logger.error(`   File: ${log.position.file || 'unknown'}`);
             logger.error(`   Line: ${log.position.line || 'unknown'}`);
+            logger.error(`   Column: ${log.position.column || 'unknown'}`);
+          }
+          if (log.position && log.position.file && existsSync(log.position.file)) {
+            try {
+              const fileContent = Bun.file(log.position.file).text();
+              const lines = fileContent.split('\n');
+              const line = lines[log.position.line - 1];
+              if (line) {
+                logger.error(`   Code: ${line.trim()}`);
+                logger.error(`         ${' '.repeat(log.position.column - 1)}^`);
+              }
+            } catch (e) {}
           }
         });
+      } else {
+        logger.error('No detailed logs available');
       }
       
       throw new Error('JavaScript bundling failed');
     }
     
+    const entryPoints = result.outputs.filter(o => o.kind === 'entry-point');
+    const chunks = result.outputs.filter(o => o.kind === 'chunk');
+    
     logger.success('✅ JavaScript bundled successfully');
-    logger.info(`   Entry points: ${result.outputs.filter(o => o.kind === 'entry-point').length}`);
-    logger.info(`   Chunks: ${result.outputs.filter(o => o.kind === 'chunk').length}`);
+    logger.info(`   Entry points: ${entryPoints.length}`);
+    logger.info(`   Chunks: ${chunks.length}`);
+    
+    result.outputs.forEach(output => {
+      const size = (output.size / 1024).toFixed(2);
+      logger.debug(`   📄 ${output.path.split('/').pop()} (${size} KB)`);
+    });
     
     const totalSize = result.outputs.reduce((sum, o) => sum + (o.size || 0), 0);
     logger.info(`   Total size: ${(totalSize / 1024).toFixed(2)} KB`);
@@ -147,12 +199,59 @@ async function bundleJavaScript(buildEntry, outDir, envVars, buildDir) {
     
   } catch (error) {
     logger.error('❌ Bundling error: ' + error.message);
+    if (error.stack) {
+      logger.error('Stack trace:');
+      logger.error(error.stack);
+    }
     throw error;
   }
 }
 
-function showBuildSummary(routes, serverIslands, clientRoutes, duration) {
-  logger.success(`✨ Build complete in ${duration}ms`);
+async function processSCSS(root, buildDir) {
+  const srcStylesDir = join(root, 'src', 'styles');
+  if (!existsSync(srcStylesDir)) return;
+  
+  try {
+    const sass = await import('sass').catch(() => {
+      logger.warn('⚠️  sass package not installed. Install with: bun add sass');
+      return null;
+    });
+    
+    if (!sass) return;
+    
+    const { readdirSync } = await import('fs');
+    const scssFiles = readdirSync(srcStylesDir).filter(f => 
+      f.endsWith('.scss') || f.endsWith('.sass')
+    );
+    
+    if (scssFiles.length === 0) return;
+    
+    logger.info(`📝 Processing ${scssFiles.length} SCSS/SASS files...`);
+    
+    for (const file of scssFiles) {
+      const srcPath = join(srcStylesDir, file);
+      const cssPath = join(buildDir, 'styles', file.replace(/\.(scss|sass)$/, '.css'));
+      
+      mkdirSync(join(buildDir, 'styles'), { recursive: true });
+      
+      const result = sass.compile(srcPath, {
+        style: 'compressed',
+        sourceMap: false,
+        loadPaths: [srcStylesDir, join(root, 'node_modules')]
+      });
+      
+      await Bun.write(cssPath, result.css);
+      logger.debug(`   ${file} → ${file.replace(/\.(scss|sass)$/, '.css')}`);
+    }
+    
+    logger.success(`✅ Processed ${scssFiles.length} SCSS files`);
+  } catch (error) {
+    logger.error(`SCSS processing failed: ${error.message}`);
+  }
+}
+
+function showBuildSummary(routes, serverIslands, clientRoutes, durationMs, durationMicro) {
+  logger.success(`✨ Build complete in ${durationMs.toFixed(3)}ms (${durationMicro.toFixed(0)}µs)`);
   logger.bigLog('BUILD SUMMARY', { color: 'green' });
   logger.info(`📄 Total routes: ${routes.length}`);
   logger.info(`🏝️  Server Islands (SSG): ${serverIslands.length}`);
@@ -160,9 +259,15 @@ function showBuildSummary(routes, serverIslands, clientRoutes, duration) {
   logger.info(`🗺️  Sitemap: dist/sitemap.xml`);
   logger.info(`🤖 robots.txt: dist/robots.txt`);
   
+  const cacheStats = globalCache.getStats();
+  logger.info(`📊 Cache: ${cacheStats.hitRate} hit rate (${cacheStats.hits}/${cacheStats.hits + cacheStats.misses})`);
+  
   if (serverIslands.length > 0) {
     logger.success('✅ Server Islands enabled - INSTANT content delivery!');
   }
   
   logger.bigLog('READY TO DEPLOY 🚀', { color: 'green' });
+  
+  // ✅ Force log flush
+  logger.debug('Build complete, exiting...');
 }