bertui 1.2.7 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bertui",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "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",

package/src/build/compiler/index.js

@@ -1,4 +1,4 @@
-// bertui/src/build/compiler/index.js - WITH IMPORTHOW + NODE MODULE SUPPORT
+// bertui/src/build/compiler/index.js
 import { join } from 'path';
 import { existsSync } from 'fs';
 import logger from '../../logger/logger.js';
@@ -6,14 +6,8 @@ import { discoverRoutes } from './route-discoverer.js';
 import { compileBuildDirectory } from './file-transpiler.js';
 import { generateBuildRouter } from './router-generator.js';
 
-/**
- * @param {string} root
- * @param {string} buildDir
- * @param {Object} envVars
- * @param {Object} config    - full bertui config (includes importhow)
- */
 export async function compileForBuild(root, buildDir, envVars, config = {}) {
-  const srcDir  = join(root, 'src');
+  const srcDir   = join(root, 'src');
   const pagesDir = join(srcDir, 'pages');
 
   if (!existsSync(srcDir)) {
@@ -21,33 +15,17 @@ export async function compileForBuild(root, buildDir, envVars, config = {}) {
   }
 
   const importhow = config.importhow || {};
-
-  let routes       = [];
-  let serverIslands = [];
-  let clientRoutes  = [];
+  let routes = [];
 
   if (existsSync(pagesDir)) {
     routes = await discoverRoutes(pagesDir);
-
-    for (const route of routes) {
-      const sourceCode = await Bun.file(route.path).text();
-      const isServerIsland = sourceCode.includes('export const render = "server"');
-
-      if (isServerIsland) {
-        serverIslands.push(route);
-        logger.success(`🏝️  Server Island: ${route.route}`);
-      } else {
-        clientRoutes.push(route);
-      }
-    }
   }
 
-  // Pass importhow so alias dirs also get compiled
   await compileBuildDirectory(srcDir, buildDir, root, envVars, importhow);
 
   if (routes.length > 0) {
     await generateBuildRouter(routes, buildDir);
   }
 
-  return { routes, serverIslands, clientRoutes };
+  return { routes };
 }

package/src/build/compiler/router-generator.js

@@ -7,14 +7,13 @@ export async function generateBuildRouter(routes, buildDir) {
     const importPath = `./pages/${route.file.replace(/\.(jsx|tsx|ts)$/, '.js')}`;
     return `import ${componentName} from '${importPath}';`;
   }).join('\n');
-  
+
   const routeConfigs = routes.map((route, i) => {
     const componentName = `Page${i}`;
     return `  { path: '${route.route}', component: ${componentName}, type: '${route.type}' }`;
   }).join(',\n');
-  
+
   const routerCode = `import React, { useState, useEffect, createContext, useContext } from 'react';
-import { createRoot } from 'react-dom/client';
 
 const RouterContext = createContext(null);
 
@@ -77,16 +76,16 @@ export function Router({ routes }) {
 
 export function Link({ to, children, ...props }) {
   const { navigate } = useRouter();
-  return React.createElement('a', { 
-    href: to, 
-    onClick: (e) => { e.preventDefault(); navigate(to); }, 
-    ...props 
+  return React.createElement('a', {
+    href: to,
+    onClick: (e) => { e.preventDefault(); navigate(to); },
+    ...props
   }, children);
 }
 
 function NotFound() {
   return React.createElement('div', {
-    style: { display: 'flex', flexDirection: 'column', alignItems: 'center', 
+    style: { display: 'flex', flexDirection: 'column', alignItems: 'center',
              justifyContent: 'center', minHeight: '100vh', fontFamily: 'system-ui' }
   },
     React.createElement('h1', { style: { fontSize: '6rem', margin: 0 } }, '404'),
@@ -100,18 +99,7 @@ ${imports}
 export const routes = [
 ${routeConfigs}
 ];
-
-// Guard against double-mount. router.js is imported by main.js — if it ever
-// gets evaluated more than once (e.g. duplicate script tags, HMR quirks),
-// this ensures React never calls createRoot on the same container twice,
-// which causes "Node.removeChild: The node to be removed is not a child" crashes.
-if (!window.__BERTUI_MOUNTED__) {
-  window.__BERTUI_MOUNTED__ = true;
-  const container = document.getElementById('root');
-  const app = React.createElement(Router, { routes });
-  createRoot(container).render(app);
-}
 `;
-  
+
   await Bun.write(join(buildDir, 'router.js'), routerCode);
 }

package/src/build/generators/html-generator.js

@@ -4,34 +4,27 @@ import { mkdirSync, existsSync, cpSync } from 'fs';
 import logger from '../../logger/logger.js';
 import { extractMetaFromSource } from '../../utils/meta-extractor.js';
 
-export async function generateProductionHTML(root, outDir, buildDir, buildResult, routes, serverIslands, config) {
+export async function generateProductionHTML(root, outDir, buildResult, routes, config) {
   const mainBundle = buildResult.outputs.find(o =>
     o.path.includes('main') && o.kind === 'entry-point'
   );
 
   if (!mainBundle) {
-    logger.error('❌ Could not find main bundle');
+    logger.error('Could not find main bundle');
     return;
   }
 
   const bundlePath = relative(outDir, mainBundle.path).replace(/\\/g, '/');
   const defaultMeta = config.meta || {};
-
   const bertuiPackages = await copyBertuiPackagesToProduction(root, outDir);
 
-  logger.info(`📄 Generating HTML for ${routes.length} routes...`);
-
-  const BATCH_SIZE = 5;
+  logger.info(`Generating HTML for ${routes.length} routes...`);
 
-  for (let i = 0; i < routes.length; i += BATCH_SIZE) {
-    const batch = routes.slice(i, i + BATCH_SIZE);
-    logger.debug(`Processing batch ${Math.floor(i / BATCH_SIZE) + 1}/${Math.ceil(routes.length / BATCH_SIZE)}`);
-    for (const route of batch) {
-      await processSingleRoute(route, config, defaultMeta, bundlePath, outDir, bertuiPackages);
-    }
+  for (const route of routes) {
+    await processSingleRoute(route, config, defaultMeta, bundlePath, outDir, bertuiPackages);
   }
 
-  logger.success(`✅ HTML generation complete for ${routes.length} routes`);
+  logger.success(`HTML generation complete for ${routes.length} routes`);
 }
 
 async function copyBertuiPackagesToProduction(root, outDir) {
@@ -46,7 +39,6 @@ async function copyBertuiPackagesToProduction(root, outDir) {
       const bertuiIconsDest = join(outDir, 'node_modules', 'bertui-icons');
       mkdirSync(join(outDir, 'node_modules'), { recursive: true });
       cpSync(bertuiIconsSource, bertuiIconsDest, { recursive: true });
-      logger.success('✅ Copied bertui-icons to dist/node_modules/');
       packages.bertuiIcons = true;
     } catch (error) {
       logger.error(`Failed to copy bertui-icons: ${error.message}`);
@@ -61,7 +53,6 @@ async function copyBertuiPackagesToProduction(root, outDir) {
       const minCSSPath = join(bertuiAnimateSource, 'bertui-animate.min.css');
       if (existsSync(minCSSPath)) {
         cpSync(minCSSPath, join(bertuiAnimateDest, 'bertui-animate.min.css'));
-        logger.success('✅ Copied bertui-animate.min.css to dist/css/');
         packages.bertuiAnimate = true;
       }
     } catch (error) {
@@ -75,7 +66,6 @@ async function copyBertuiPackagesToProduction(root, outDir) {
       const elysiaEdenDest = join(outDir, 'node_modules', '@elysiajs', 'eden');
       mkdirSync(join(outDir, 'node_modules', '@elysiajs'), { recursive: true });
       cpSync(elysiaEdenSource, elysiaEdenDest, { recursive: true });
-      logger.success('✅ Copied @elysiajs/eden to dist/node_modules/');
       packages.elysiaEden = true;
     } catch (error) {
       logger.error(`Failed to copy @elysiajs/eden: ${error.message}`);
@@ -103,11 +93,10 @@ async function processSingleRoute(route, config, defaultMeta, bundlePath, outDir
     }
 
     await Bun.write(htmlPath, html);
-    logger.success(`✅ ${route.route}`);
+    logger.success(`${route.route}`);
 
   } catch (error) {
     logger.error(`Failed HTML for ${route.route}: ${error.message}`);
-    console.error(error);
   }
 }
 
@@ -153,7 +142,6 @@ ${bertuiAnimateCSS}
     }
   }
   </script>
-  <script>window.__BERTUI_HYDRATE__ = false;</script>
 </head>
 <body>
   <div id="root"></div>

package/src/build/server-island-validator.js

@@ -1,175 +1,12 @@
 // bertui/src/build/server-island-validator.js
-// Fixed validation for Server Islands - no false positives!
+// Server Islands removed — all pages are client-rendered.
 
-import logger from '../logger/logger.js';
-
-/**
- * Validates that a Server Island component follows all rules
- * @param {string} sourceCode - The component source code
- * @param {string} filePath - Path to the file (for error messages)
- * @returns {{ valid: boolean, errors: string[] }}
- */
 export function validateServerIsland(sourceCode, filePath) {
-  const errors = [];
-  
-  // SUPER AGGRESSIVE STRIPPING: Remove EVERYTHING that could be a false positive
-  
-  // First, remove all JSX prop values that contain code examples
-  let cleanedCode = sourceCode
-    // Remove the entire content of <Code> components (most common culprit)
-    .replace(/<Code[^>]*>[\s\S]*?<\/Code>/g, '')
-    // Remove the entire content of <InlineCode> components
-    .replace(/<InlineCode[^>]*>[\s\S]*?<\/InlineCode>/g, '')
-    // Remove any JSX expression that looks like it contains code
-    .replace(/\{`[\s\S]*?`\}/g, '{}')
-    .replace(/\{[\s\S]*?import[\s\S]*?\}/g, '{}')
-    .replace(/\{[\s\S]*?useState[\s\S]*?\}/g, '{}')
-    .replace(/\{[\s\S]*?useEffect[\s\S]*?\}/g, '{}')
-    .replace(/\{[\s\S]*?fetch\([\s\S]*?\}/g, '{}');
-  
-  // Then strip all string literals
-  cleanedCode = cleanedCode
-    .replace(/`[\s\S]*?`/g, '""')
-    .replace(/"(?:[^"\\]|\\.)*"/g, '""')
-    .replace(/'(?:[^'\\]|\\.)*'/g, "''")
-    // Remove comments
-    .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
-  
-  // Rule 1: No React hooks (check the cleaned code only)
-  const hookPatterns = [
-    'useState', 'useEffect', 'useContext', 'useReducer',
-    'useCallback', 'useMemo', 'useRef', 'useImperativeHandle',
-    'useLayoutEffect', 'useDebugValue', 'useId', 'useDeferredValue',
-    'useTransition', 'useSyncExternalStore'
-  ];
-  
-  for (const hook of hookPatterns) {
-    // Look for the hook as a function call, but only in the cleaned code
-    const regex = new RegExp(`\\b${hook}\\s*\\(`, 'g');
-    
-    // Also check that it's not preceded by "import" or part of a comment
-    const matches = cleanedCode.match(regex);
-    if (matches) {
-      // Verify this isn't in an import statement by checking context
-      const hookIndex = cleanedCode.indexOf(matches[0]);
-      const contextBefore = cleanedCode.substring(Math.max(0, hookIndex - 50), hookIndex);
-      
-      if (!contextBefore.includes('import')) {
-        errors.push(`❌ Uses React hook: ${hook}`);
-      }
-    }
-  }
-  
-  // Rule 2: No bertui/router imports
-  if (sourceCode.includes('from \'bertui/router\'') || 
-      sourceCode.includes('from "bertui/router"')) {
-    errors.push('❌ Imports from \'bertui/router\' (use <a> tags instead of Link)');
-  }
-  
-  // Rule 3: No browser APIs (check cleaned code)
-  const browserAPIs = [
-    { pattern: '\\bwindow\\.(?!location)', name: 'window' },
-    { pattern: '\\bdocument\\.', name: 'document' },
-    { pattern: '\\blocalStorage\\.', name: 'localStorage' },
-    { pattern: '\\bsessionStorage\\.', name: 'sessionStorage' },
-    { pattern: '\\bnavigator\\.', name: 'navigator' },
-    { pattern: '\\blocation\\.(?!href)', name: 'location' },
-    { pattern: '\\bhistory\\.', name: 'history' },
-    { pattern: '\\bfetch\\s*\\(', name: 'fetch' },
-    { pattern: '\\.addEventListener\\s*\\(', name: 'addEventListener' },
-    { pattern: '\\.removeEventListener\\s*\\(', name: 'removeEventListener' },
-    { pattern: '\\bsetTimeout\\s*\\(', name: 'setTimeout' },
-    { pattern: '\\bsetInterval\\s*\\(', name: 'setInterval' },
-    { pattern: '\\brequestAnimationFrame\\s*\\(', name: 'requestAnimationFrame' },
-    { pattern: '\\bconsole\\.', name: 'console' }
-  ];
-  
-  for (const api of browserAPIs) {
-    const regex = new RegExp(api.pattern, 'g');
-    if (regex.test(cleanedCode)) {
-      if (api.name === 'console') {
-        logger.warn(`⚠️  ${filePath} uses console.log (will not work in static HTML)`);
-      } else {
-        errors.push(`❌ Uses browser API: ${api.name}`);
-      }
-    }
-  }
-  
-  // Rule 4: No event handlers (check cleaned code)
-  const eventHandlers = [
-    'onClick=', 'onChange=', 'onSubmit=', 'onInput=', 'onFocus=',
-    'onBlur=', 'onMouseEnter=', 'onMouseLeave=', 'onKeyDown=',
-    'onKeyUp=', 'onScroll='
-  ];
-  
-  for (const handler of eventHandlers) {
-    const escapedHandler = handler.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(`\\b${escapedHandler}\\s*{`, 'g');
-    if (regex.test(cleanedCode)) {
-      errors.push(`❌ Uses event handler: ${handler.replace('=', '')} (Server Islands are static HTML)`);
-    }
-  }
-  
-  // Rule 5: Check for dynamic imports
-  if (/import\s*\(/.test(cleanedCode)) {
-    errors.push('❌ Uses dynamic import() (not supported in Server Islands)');
-  }
-  
-  // Rule 6: Check for async/await
-  if (/async\s+function|async\s*\(|async\s+\w+\s*\(/.test(cleanedCode)) {
-    errors.push('❌ Uses async/await (Server Islands must be synchronous)');
-  }
-  
-  const valid = errors.length === 0;
-  
-  return { valid, errors };
+  return { valid: true, errors: [] };
 }
 
+export function displayValidationErrors(filePath, errors) {}
 
-
-/**
- * Display validation errors in a clear format
- */
-export function displayValidationErrors(filePath, errors) {
-  logger.error(`\n🏝️  Server Island validation failed: ${filePath}`);
-  logger.error('\nViolations:');
-  errors.forEach(error => logger.error(`  ${error}`));
-  logger.error('\n📖 Server Island Rules:');
-  logger.error('  ✅ Pure static JSX only');
-  logger.error('  ❌ No React hooks (useState, useEffect, etc.)');
-  logger.error('  ❌ No Link component (use <a> tags)');
-  logger.error('  ❌ No browser APIs (window, document, fetch)');
-  logger.error('  ❌ No event handlers (onClick, onChange, etc.)');
-  logger.error('\n💡 Tip: Remove the "export const render = \\"server\\"" line');
-  logger.error('   if you need these features (page will be client-only).\n');
-}
-
-/**
- * Extract and validate all Server Islands in a project
- */
 export async function validateAllServerIslands(routes) {
-  const serverIslands = [];
-  const validationResults = [];
-  
-  for (const route of routes) {
-    const sourceCode = await Bun.file(route.path).text();
-    const isServerIsland = sourceCode.includes('export const render = "server"');
-    
-    if (isServerIsland) {
-      const validation = validateServerIsland(sourceCode, route.path);
-      
-      validationResults.push({
-        route: route.route,
-        path: route.path,
-        ...validation
-      });
-      
-      if (validation.valid) {
-        serverIslands.push(route);
-      }
-    }
-  }
-  
-  return { serverIslands, validationResults };
+  return { serverIslands: [], validationResults: [] };
 }

package/src/build.js

@@ -1,6 +1,6 @@
 // bertui/src/build.js
 import { join } from 'path';
-import { existsSync, mkdirSync, rmSync, readdirSync, statSync } from 'fs';
+import { existsSync, mkdirSync, rmSync, readdirSync } from 'fs';
 import logger from './logger/logger.js';
 import { loadEnvVariables } from './utils/env.js';
 import { globalCache } from './utils/cache.js';
@@ -13,9 +13,8 @@ import { generateSitemap } from './build/generators/sitemap-generator.js';
 import { generateRobots } from './build/generators/robots-generator.js';
 import { compileLayouts } from './layouts/index.js';
 import { compileLoadingComponents } from './loading/index.js';
-import { analyzeRoutes, logHydrationReport } from './hydration/index.js';
+import { analyzeRoutes } from './hydration/index.js';
 import { analyzeBuild } from './analyzer/index.js';
-import { buildAliasMap } from './utils/importhow.js';
 
 const TOTAL_STEPS = 10;
 
@@ -46,8 +45,8 @@ export async function buildProduction(options = {}) {
 
     // ── Step 2: Compile ──────────────────────────────────────────────────────
     logger.step(2, TOTAL_STEPS, 'Compiling');
-    const { routes, serverIslands, clientRoutes } = await compileForBuild(root, buildDir, envVars, config);
-    logger.stepDone('Compiling', `${routes.length} routes · ${serverIslands.length} islands`);
+    const { routes } = await compileForBuild(root, buildDir, envVars, config);
+    logger.stepDone('Compiling', `${routes.length} routes`);
 
     // ── Step 3: Layouts ──────────────────────────────────────────────────────
     logger.step(3, TOTAL_STEPS, 'Layouts');
@@ -78,14 +77,16 @@ export async function buildProduction(options = {}) {
     // ── Step 8: Bundle JS ────────────────────────────────────────────────────
     logger.step(8, TOTAL_STEPS, 'Bundling JS');
     const buildEntry = join(buildDir, 'main.js');
-    if (!existsSync(buildEntry)) throw new Error('main.js not found in build dir');
-    const result = await bundleJavaScript(buildEntry, outDir, envVars, buildDir, analyzedRoutes, importhow, root, config);
+    if (!existsSync(buildEntry)) {
+      throw new Error('main.js not found in build dir — make sure src/main.jsx exists');
+    }
+    const result = await bundleJavaScript(buildEntry, outDir, envVars, buildDir, root, config);
     totalKB = (result.outputs.reduce((a, o) => a + (o.size || 0), 0) / 1024).toFixed(1);
     logger.stepDone('Bundling JS', `${totalKB} KB · tree-shaken`);
 
     // ── Step 9: HTML ─────────────────────────────────────────────────────────
     logger.step(9, TOTAL_STEPS, 'Generating HTML');
-    await generateProductionHTML(root, outDir, buildDir, result, routes, serverIslands, config);
+    await generateProductionHTML(root, outDir, result, routes, config);
     logger.stepDone('Generating HTML', `${routes.length} pages`);
 
     // ── Step 10: Sitemap + robots ────────────────────────────────────────────
@@ -94,32 +95,27 @@ export async function buildProduction(options = {}) {
     await generateRobots(config, outDir, routes);
     logger.stepDone('Sitemap & robots');
 
-    // Delete build dir AFTER HTML generation
     if (existsSync(buildDir)) rmSync(buildDir, { recursive: true, force: true });
 
-    // Generate bundle report
     try {
       await analyzeBuild(outDir, { outputFile: join(outDir, 'bundle-report.html') });
     } catch (reportErr) {
       logger.debug(`Bundle report generation skipped: ${reportErr.message}`);
     }
 
-    // ── Summary ──────────────────────────────────────────────────────────────
     logger.printSummary({
-      routes:        routes.length,
-      serverIslands: serverIslands.length,
-      interactive:   analyzedRoutes.interactive.length,
-      staticRoutes:  analyzedRoutes.static.length,
-      jsSize:        `${totalKB} KB`,
-      outDir:        'dist/',
+      routes:      routes.length,
+      interactive: analyzedRoutes.interactive.length,
+      staticRoutes: analyzedRoutes.static.length,
+      jsSize:      `${totalKB} KB`,
+      outDir:      'dist/',
     });
 
     logger.cleanup();
-
     return { success: true };
 
   } catch (error) {
-    logger.stepFail('Build', error.message);
+    logger.stepFail('Build', error?.message || String(error));
     if (existsSync(buildDir)) rmSync(buildDir, { recursive: true, force: true });
     throw error;
   }
@@ -161,6 +157,7 @@ async function generateProductionImportMap(root, config) {
 }
 
 async function copyNodeModulesToDist(root, outDir, importMap) {
+  const { mkdirSync } = await import('fs');
   const dest = join(outDir, 'assets', 'node_modules');
   mkdirSync(dest, { recursive: true });
   const src = join(root, 'node_modules');
@@ -179,23 +176,18 @@ async function copyNodeModulesToDist(root, outDir, importMap) {
   }
 }
 
-async function bundleJavaScript(buildEntry, outDir, envVars, buildDir, analyzedRoutes, importhow, root, config) {
+async function bundleJavaScript(buildEntry, outDir, envVars, buildDir, root, config) {
   const originalCwd = process.cwd();
   process.chdir(buildDir);
 
   try {
-    // Only main.js as entrypoint — router.js is imported by main.js already.
-    // Adding router.js as a second entrypoint causes it to mount twice on
-    // the same #root which triggers "Node.removeChild" DOM crashes in React.
-    const entrypoints = [buildEntry];
-
     const importMap = await generateProductionImportMap(root, config);
     await Bun.write(join(outDir, 'import-map.json'), JSON.stringify({ imports: importMap }, null, 2));
     await copyNodeModulesToDist(root, outDir, importMap);
 
-    // Copy @bunnyx/api client to dist so the importmap entry resolves
     const bunnyxSrc = join(root, 'bunnyx-api', 'api-client.js');
     if (existsSync(bunnyxSrc)) {
+      const { mkdirSync } = await import('fs');
       mkdirSync(join(outDir, 'bunnyx-api'), { recursive: true });
       await Bun.write(join(outDir, 'bunnyx-api', 'api-client.js'), Bun.file(bunnyxSrc));
     }
@@ -214,36 +206,42 @@ async function bundleJavaScript(buildEntry, outDir, envVars, buildDir, analyzedR
       },
     };
 
-    const result = await Bun.build({
-      entrypoints,
-      outdir:  join(outDir, 'assets'),
-      target:  'browser',
-      format:  'esm',
-      plugins: [cssModulePlugin],
-      minify: {
-        whitespace:  true,
-        syntax:      true,
-        identifiers: true,
-      },
-      splitting:  true,
-      sourcemap: 'external',
-      metafile:   true,
-      naming: {
-        entry: 'js/[name]-[hash].js',
-        chunk: 'js/chunks/[name]-[hash].js',
-        asset: 'assets/[name]-[hash].[ext]',
-      },
-      external: ['react', 'react-dom', 'react-dom/client', 'react/jsx-runtime', '@bunnyx/api'],
-      define: {
-        'process.env.NODE_ENV': '"production"',
-        ...Object.fromEntries(
-          Object.entries(envVars).map(([k, v]) => [`process.env.${k}`, JSON.stringify(v)])
-        ),
-      },
-    });
+    let result;
+    try {
+      result = await Bun.build({
+        entrypoints: [buildEntry],
+        outdir:  join(outDir, 'assets'),
+        target:  'browser',
+        format:  'esm',
+        plugins: [cssModulePlugin],
+        minify: {
+          whitespace:  true,
+          syntax:      true,
+          identifiers: true,
+        },
+        splitting:  true,
+        sourcemap: 'external',
+        metafile:   true,
+        naming: {
+          entry: 'js/[name]-[hash].js',
+          chunk: 'js/chunks/[name]-[hash].js',
+          asset: 'assets/[name]-[hash].[ext]',
+        },
+        external: ['react', 'react-dom', 'react-dom/client', 'react/jsx-runtime', '@bunnyx/api'],
+        define: {
+          'process.env.NODE_ENV': '"production"',
+          ...Object.fromEntries(
+            Object.entries(envVars).map(([k, v]) => [`process.env.${k}`, JSON.stringify(v)])
+          ),
+        },
+      });
+    } catch (err) {
+      throw new Error(`Bun.build failed: ${err?.message || String(err)}`);
+    }
 
     if (!result.success) {
-      throw new Error(`Bundle failed\n${result.logs?.map(l => l.message).join('\n') || 'Unknown error'}`);
+      const msgs = (result.logs || []).map(l => l?.message || l?.text || JSON.stringify(l)).join('\n');
+      throw new Error(`Bundle failed\n${msgs || 'Check your imports for .jsx extensions or unresolvable paths'}`);
     }
 
     if (result.metafile) {
@@ -262,7 +260,7 @@ export async function build(options = {}) {
     await buildProduction(options);
     process.exit(0);
   } catch (error) {
-    console.error(error);
+    console.error('Build error:', error?.message || String(error));
     process.exit(1);
   }
 }