@grupodiariodaregiao/bunstone 0.5.1 → 0.5.2

package/bin/cli.ts

@@ -504,32 +504,135 @@ async function scaffold(projectName_?: string) {
 	}
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Help
-// ─────────────────────────────────────────────────────────────────────────────
+// ── Help ───────────────────────────────────────────────────────────────────
 
 function printHelp() {
 	console.log(`
 ${bold("bunstone")} — CLI for the Bunstone framework
 
 ${cyan("Usage:")}
-  bunstone new <project-name>          Scaffold a new project
-  bunstone run [bun-flags] <entry>     Run your app with enhanced error messages
-  bunstone exports                     List all public exports
+  bunstone new <project-name>           Scaffold a new project
+  bunstone run [bun-flags] <entry>      Run your app with enhanced error messages
+  bunstone build [entry] [options]      Build your app for production
+  bunstone exports                      List all public exports
+
+${cyan("Build Options:")}
+  --views <dir>                         Directory containing React views (default: src/views)
+  --out <dir>                           Output directory (default: dist)
+  --compile                             Compile to a standalone binary
+  --no-bundle                           Skip application bundling (only bundle views)
 
 ${cyan("Examples:")}
   bunstone new my-api
   bunstone run src/main.ts
-  bunstone run --watch src/main.ts
+  bunstone build src/main.ts
+  bunstone build --compile
 `);
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// bunstone build [entry] [options]
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function buildCommand(buildArgs: string[]) {
+	console.log(`${cyan(BORDER)}`);
+	console.log(`${cyan(bold("  📦  Bunstone — Production Build"))}`);
+	console.log(`${cyan(BORDER)}\n`);
+
+	let entry = "";
+	let viewsDir = "src/views";
+	let outDir = "dist";
+	let compile = false;
+	let skipAppBundle = false;
+
+	for (let i = 0; i < buildArgs.length; i++) {
+		const arg = buildArgs[i];
+		if (arg === "--views") {
+			viewsDir = buildArgs[++i];
+		} else if (arg === "--out") {
+			outDir = buildArgs[++i];
+		} else if (arg === "--compile") {
+			compile = true;
+		} else if (arg === "--no-bundle") {
+			skipAppBundle = true;
+		} else if (!arg.startsWith("-")) {
+			entry = arg;
+		}
+	}
+
+	// Try to detect entry if not provided
+	if (!entry && !skipAppBundle) {
+		const candidates = ["src/index.ts", "index.ts", "src/main.ts", "main.ts"];
+		for (const c of candidates) {
+			if (await Bun.file(join(process.cwd(), c)).exists()) {
+				entry = c;
+				break;
+			}
+		}
+	}
+
+	if (!entry && !skipAppBundle) {
+		console.error(red("  ✖  No entrypoint found or specified."));
+		console.error(
+			gray("     Please specify an entrypoint: bunstone build src/index.ts"),
+		);
+		process.exit(1);
+	}
+
+	try {
+		// We use dynamic import for Bundler to keep CLI light if not building
+		// Since we are in the same repo, we can import from the lib
+		const { Bundler } = await import("../lib/utils/bundler");
+
+		// 1. Build views
+		const viewsDirAbs = join(process.cwd(), viewsDir);
+		const viewsStat = await Bun.file(viewsDirAbs)
+			.stat()
+			.catch(() => null);
+
+		if (viewsStat && viewsStat.isDirectory()) {
+			console.log(
+				`  ${yellow("→")} Bundling React views from ${bold(viewsDir)}...`,
+			);
+			await Bundler.buildViews(viewsDir);
+		} else {
+			console.log(
+				`  ${gray("○")} No views directory found at ${viewsDir}, skipping view bundling.`,
+			);
+		}
+
+		// 2. Build app
+		if (!skipAppBundle) {
+			console.log(
+				`  ${yellow("→")} Bundling application ${bold(entry)} to ${bold(outDir)}...`,
+			);
+			await Bundler.buildApp(entry, outDir, compile);
+		}
+
+		console.log(`\n${green("  ✅  Build completed successfully!")}`);
+		if (!skipAppBundle) {
+			console.log(
+				`     Output: ${bold(outDir + (compile ? "/app" : "/index.js"))}`,
+			);
+		}
+	} catch (error: any) {
+		console.error(`\n${red("  ✖  Build failed:")}`);
+		console.error(red(`     ${error.message}`));
+		process.exit(1);
+	}
+}
+
 async function main() {
 	if (command === "run") {
 		await runCommand(args.slice(1));
 		return;
 	}
 
+	if (command === "build") {
+		await buildCommand(args.slice(1));
+		return;
+	}
+
 	if (command === "exports") {
 		await exportsCommand();
 		return;

package/dist/index.js

@@ -100673,9 +100673,7 @@ function toPublicBucketPath(key) {
   return `/${normalizeS3Key(key)}`;
 }
 // lib/app-startup.ts
-import { statSync as statSync2 } from "fs";
-import { mkdir, readdir } from "fs/promises";
-import { basename, extname as extname2, join as join3, resolve } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
 import { cors } from "@elysiajs/cors";
 import { html } from "@elysiajs/html";
 import jwt2 from "@elysiajs/jwt";
@@ -117539,11 +117537,158 @@ function Render(component) {
   };
 }
 
+// lib/utils/bundler.ts
+import { statSync as statSync2 } from "fs";
+import { mkdir, readdir } from "fs/promises";
+import { basename, extname as extname2, join as join3, resolve } from "path";
+
 // lib/utils/cwd.ts
 function cwd() {
   return process.cwd();
 }
 
+// lib/utils/bundler.ts
+class Bundler {
+  static logger = new Logger("Bundler");
+  static async buildViews(viewsDir, outDir = "./public") {
+    const viewsDirAbs = resolve(viewsDir);
+    const viewsDirStat = statSync2(viewsDirAbs, { throwIfNoEntry: false });
+    if (!viewsDirStat || !viewsDirStat.isDirectory())
+      return;
+    const bunstoneDir = join3(cwd(), ".bunstone");
+    const bunstoneDirExists = await Bun.file(bunstoneDir).exists();
+    if (!bunstoneDirExists) {
+      await mkdir(bunstoneDir, { recursive: true });
+    }
+    const files = await Bundler.getFilesRecursively(viewsDirAbs);
+    Bundler.logger.log(`Auto-bundling views from ${viewsDirAbs} (${files.length} views found)`);
+    for (const absolutePath of files) {
+      if (absolutePath.endsWith(".tsx") || absolutePath.endsWith(".jsx")) {
+        const componentName = basename(absolutePath, extname2(absolutePath));
+        const entryPath = join3(bunstoneDir, `${componentName}.client.tsx`);
+        const bundleName = `${componentName.toLowerCase()}.bundle.js`;
+        const entryContent = Bundler.generateHydrationEntry(absolutePath, componentName);
+        await Bun.write(entryPath, entryContent);
+        await Bundler.bundleView(entryPath, outDir, bundleName);
+      }
+    }
+  }
+  static async bundleView(entryPath, outdir, outputName) {
+    try {
+      const result = await Bun.build({
+        entrypoints: [entryPath],
+        outdir,
+        naming: outputName,
+        minify: true,
+        external: [
+          "react",
+          "react-dom",
+          "react-dom/client",
+          "react/jsx-runtime",
+          "react/jsx-dev-runtime"
+        ]
+      });
+      if (!result.success) {
+        Bundler.logger.error(`Bundle failed for ${outputName}: ${result.logs.map((l5) => l5.message).join(`
+`)}`);
+      } else {
+        Bundler.logger.log(`Bundle created successfully: ${outdir}/${outputName}`);
+      }
+    } catch (error48) {
+      Bundler.logger.error(`Error during bundling ${outputName}: ${error48.message}`);
+    }
+  }
+  static async getFilesRecursively(dir) {
+    let results = [];
+    const list = await readdir(dir);
+    for (const file2 of list) {
+      const fullPath = join3(dir, file2);
+      const stat = statSync2(fullPath);
+      if (stat?.isDirectory()) {
+        results = results.concat(await Bundler.getFilesRecursively(fullPath));
+      } else {
+        results.push(resolve(fullPath));
+      }
+    }
+    return results;
+  }
+  static generateHydrationEntry(path3, name3) {
+    return `
+import React from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import * as Mod from '${path3}';
+
+const Component = Mod['${name3}'] || Mod.default;
+
+function hydrate() {
+  const dataElement = document.getElementById("__BUNSTONE_DATA__");
+  const data = dataElement ? JSON.parse(dataElement.textContent || "{}") : {};
+
+  if (typeof document !== 'undefined' && Component) {
+    const root = document.getElementById("root");
+    if (root) {
+      try {
+        hydrateRoot(root, React.createElement(Component, data));
+        console.log('[Bunstone] Hydration successful for component: ${name3}');
+      } catch (e) {
+        console.error('[Bunstone] Hydration failed for component: ${name3}', e);
+      }
+    } else {
+      console.error('[Bunstone] Root element "root" not found for hydration.');
+    }
+  } else {
+    console.error('[Bunstone] Component ${name3} not found in bundle.');
+  }
+}
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', hydrate);
+} else {
+  hydrate();
+}
+`;
+  }
+  static async buildApp(entrypoint, outdir = "./dist", compile2 = false) {
+    const entryAbs = resolve(entrypoint);
+    if (!await Bun.file(entryAbs).exists()) {
+      throw new Error(`Entrypoint not found: ${entrypoint}`);
+    }
+    Bundler.logger.log(`Building application from ${entrypoint}...`);
+    if (compile2) {
+      const result = await Bun.spawn([
+        "bun",
+        "build",
+        entrypoint,
+        "--compile",
+        "--outfile",
+        join3(outdir, "app")
+      ], {
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      const exitCode = await result.exited;
+      if (exitCode !== 0) {
+        throw new Error("Compilation failed");
+      }
+    } else {
+      const result = await Bun.build({
+        entrypoints: [entrypoint],
+        outdir,
+        target: "bun",
+        minify: true,
+        sourcemap: "external",
+        external: ["react", "react-dom", "elysia", "@elysiajs/*"]
+      });
+      if (!result.success) {
+        Bundler.logger.error("Build failed:", result.logs.map((l5) => l5.message).join(`
+`));
+        throw new Error("Application build failed");
+      }
+      Bundler.logger.log(`Application built successfully to ${outdir}`);
+    }
+  }
+}
+
 // lib/app-startup.ts
 class AppStartup {
   static elysia = new Elysia;
@@ -117554,7 +117699,6 @@ class AppStartup {
   static destroyPromise = null;
   static hasBeenDestroyed = false;
   static rootModule;
-  static viewBundles = new Map;
   static globalRateLimitConfig;
   static rateLimitService = new RateLimitService;
   static async create(module, options) {
@@ -117567,14 +117711,14 @@ class AppStartup {
       AppStartup.hasBeenDestroyed = false;
       const publicExists = await Bun.file("public").exists();
       if (!publicExists)
-        await mkdir("./public", { recursive: true });
+        await mkdir2("./public", { recursive: true });
       AppStartup.elysia.use(html());
       AppStartup.elysia.use(staticPlugin({
         assets: "public",
         prefix: "/public"
       }));
       if (options?.viewsDir) {
-        AppStartup.autoBundle(options.viewsDir).catch((err) => {
+        Bundler.buildViews(options.viewsDir).catch((err) => {
           AppStartup.logger.error(`Failed to auto-bundle views: ${err.message}`);
         });
       }
@@ -117667,104 +117811,6 @@ class AppStartup {
       process.exit(1);
     }
   }
-  static async bundle(entryPath, outputName) {
-    try {
-      const result = await Bun.build({
-        entrypoints: [entryPath],
-        outdir: "./public",
-        naming: outputName,
-        minify: true,
-        external: [
-          "react",
-          "react-dom",
-          "react-dom/client",
-          "react/jsx-runtime",
-          "react/jsx-dev-runtime"
-        ]
-      });
-      if (!result.success) {
-        AppStartup.logger.error(`Bundle failed for ${outputName}: ${result.logs.map((l5) => l5.message).join(`
-`)}`);
-      } else {
-        AppStartup.logger.log(`Bundle created successfully: public/${outputName}`);
-      }
-    } catch (error48) {
-      AppStartup.logger.error(`Error during bundling ${outputName}: ${error48.message}`);
-    }
-  }
-  static async autoBundle(viewsDir) {
-    const viewDirExists = await Bun.file(viewsDir).exists();
-    if (!viewDirExists)
-      return;
-    const bunstoneDirExists = await Bun.file("./.bunstone").exists();
-    if (!bunstoneDirExists) {
-      await mkdir("./.bunstone", { recursive: true });
-    }
-    const getFilesRecursively = async (dir) => {
-      let results = [];
-      const list = await readdir(dir);
-      for (const file2 of list) {
-        const fullPath = join3(dir, file2);
-        const stat = statSync2(fullPath);
-        if (stat?.isDirectory()) {
-          results = results.concat(await getFilesRecursively(fullPath));
-        } else {
-          results.push(resolve(fullPath));
-        }
-      }
-      return results;
-    };
-    const viewsDirAbs = resolve(viewsDir);
-    const files = await getFilesRecursively(viewsDirAbs);
-    AppStartup.logger.log(`Auto-bundling views from ${viewsDirAbs} (${files.length} views found)`);
-    for (const absolutePath of files) {
-      const file2 = basename(absolutePath);
-      if (file2.endsWith(".tsx") || file2.endsWith(".jsx")) {
-        const componentName = basename(file2, extname2(file2));
-        const entryPath = join3(cwd(), ".bunstone", `${componentName}.client.tsx`);
-        const entryContent = `
-import React from 'react';
-import { hydrateRoot } from 'react-dom/client';
-import * as Mod from '${absolutePath}';
-
-const Component = Mod['${componentName}'] || Mod.default;
-
-function hydrate() {
-  const dataElement = document.getElementById("__BUNSTONE_DATA__");
-  const data = dataElement ? JSON.parse(dataElement.textContent || "{}") : {};
-
-  if (typeof document !== 'undefined' && Component) {
-    const root = document.getElementById("root");
-    if (root) {
-      try {
-        hydrateRoot(root, React.createElement(Component, data));
-        console.log('[Bunstone] Hydration successful for component: ${componentName}');
-      } catch (e) {
-        console.error('[Bunstone] Hydration failed for component: ${componentName}', e);
-      }
-    } else {
-      console.error('[Bunstone] Root element "root" not found for hydration.');
-    }
-  } else {
-    console.error('[Bunstone] Component ${componentName} not found in bundle.');
-  }
-}
-
-// Ensure DOM is fully loaded before hydrating
-if (document.readyState === 'loading') {
-  document.addEventListener('DOMContentLoaded', hydrate);
-} else {
-  hydrate();
-}
-        `;
-        await Bun.write(entryPath, entryContent);
-        const bundleName = `${componentName.toLowerCase()}.bundle.js`;
-        await AppStartup.bundle(entryPath, bundleName);
-        AppStartup.viewBundles.set(componentName, bundleName);
-        AppStartup.viewBundles.set(componentName.toLowerCase(), bundleName);
-      }
-    }
-  }
   static listen(port) {
     AppStartup.logger.log(`App is running at http://localhost:${port}`);
     AppStartup.elysia.listen(port);
@@ -117806,8 +117852,9 @@ if (document.readyState === 'loading') {
         context.set.headers["Content-Type"] = "text/html; charset=utf8";
       }
       const componentName = component.name || component.displayName;
-      const bundle = result?.bundle || AppStartup.viewBundles.get(componentName) || AppStartup.viewBundles.get(componentName.toLowerCase());
-      AppStartup.logger.log(`Rendering component: ${componentName}, bundle found: ${bundle || "none"}`);
+      const bundleName = `${componentName.toLowerCase()}.bundle.js`;
+      const bundle = `/public/${bundleName}`;
+      AppStartup.logger.log(`Rendering component: ${componentName}`);
       if (!bundle) {
         AppStartup.logger.warn(`No client bundle found for component: ${componentName}. useEffect and other hooks will not work on the client.`);
       }

package/dist/lib/app-startup.d.ts

@@ -14,7 +14,6 @@ export declare class AppStartup {
     private static destroyPromise;
     private static hasBeenDestroyed;
     private static rootModule;
-    private static readonly viewBundles;
     private static globalRateLimitConfig;
     private static rateLimitService;
     /**
@@ -62,11 +61,6 @@ export declare class AppStartup {
             response: {};
         }>;
     }>;
-    /**
-     * Bundles a client-side component for hydration (internal).
-     */
-    private static bundle;
-    private static autoBundle;
     /**
      * Starts the server on the specified port.
      * @param port The port number to listen on.

package/dist/lib/utils/bundler.d.ts

@@ -0,0 +1,8 @@
+export declare class Bundler {
+    private static logger;
+    static buildViews(viewsDir: string, outDir?: string): Promise<void>;
+    private static bundleView;
+    private static getFilesRecursively;
+    private static generateHydrationEntry;
+    static buildApp(entrypoint: string, outdir?: string, compile?: boolean): Promise<void>;
+}

package/lib/app-startup.ts

@@ -43,6 +43,7 @@ import type { RateLimitMetadata } from "./ratelimit/ratelimit.decorator";
 import { RateLimitService } from "./ratelimit/ratelimit.service";
 import { RENDER_METADATA } from "./render";
 import type { Options, RateLimitGlobalConfig } from "./types/options";
+import { Bundler } from "./utils/bundler";
 import { cwd } from "./utils/cwd";
 import {
 	GlobalRegistry,
@@ -64,7 +65,6 @@ export class AppStartup {
 	private static destroyPromise: Promise<void> | null = null;
 	private static hasBeenDestroyed = false;
 	private static rootModule: any;
-	private static readonly viewBundles = new Map<string, string>();
 	private static globalRateLimitConfig: RateLimitGlobalConfig | undefined;
 	private static rateLimitService: RateLimitService = new RateLimitService();
 
@@ -97,7 +97,7 @@ export class AppStartup {
 			);
 
 			if (options?.viewsDir) {
-				AppStartup.autoBundle(options.viewsDir).catch((err) => {
+				Bundler.buildViews(options.viewsDir).catch((err) => {
 					AppStartup.logger.error(
 						`Failed to auto-bundle views: ${err.message}`,
 					);
@@ -236,129 +236,6 @@ export class AppStartup {
 		}
 	}
 
-	/**
-	 * Bundles a client-side component for hydration (internal).
-	 */
-	private static async bundle(entryPath: string, outputName: string) {
-		try {
-			const result = await Bun.build({
-				entrypoints: [entryPath],
-				outdir: "./public",
-				naming: outputName,
-				minify: true,
-				external: [
-					"react",
-					"react-dom",
-					"react-dom/client",
-					"react/jsx-runtime",
-					"react/jsx-dev-runtime",
-				],
-			});
-
-			if (!result.success) {
-				AppStartup.logger.error(
-					`Bundle failed for ${outputName}: ${result.logs
-						.map((l) => l.message)
-						.join("\n")}`,
-				);
-			} else {
-				AppStartup.logger.log(
-					`Bundle created successfully: public/${outputName}`,
-				);
-			}
-		} catch (error: any) {
-			AppStartup.logger.error(
-				`Error during bundling ${outputName}: ${error.message}`,
-			);
-		}
-	}
-
-	private static async autoBundle(viewsDir: string) {
-		const viewDirExists = await Bun.file(viewsDir).exists();
-		if (!viewDirExists) return;
-
-		const bunstoneDirExists = await Bun.file("./.bunstone").exists();
-		if (!bunstoneDirExists) {
-			await mkdir("./.bunstone", { recursive: true });
-		}
-
-		const getFilesRecursively = async (dir: string): Promise<string[]> => {
-			let results: string[] = [];
-			const list = await readdir(dir);
-			for (const file of list) {
-				const fullPath = join(dir, file);
-				const stat = statSync(fullPath);
-				if (stat?.isDirectory()) {
-					results = results.concat(await getFilesRecursively(fullPath));
-				} else {
-					results.push(resolve(fullPath));
-				}
-			}
-			return results;
-		};
-
-		const viewsDirAbs = resolve(viewsDir);
-		const files = await getFilesRecursively(viewsDirAbs);
-		AppStartup.logger.log(
-			`Auto-bundling views from ${viewsDirAbs} (${files.length} views found)`,
-		);
-
-		for (const absolutePath of files) {
-			const file = basename(absolutePath);
-			if (file.endsWith(".tsx") || file.endsWith(".jsx")) {
-				const componentName = basename(file, extname(file));
-				const entryPath = join(
-					cwd(),
-					".bunstone",
-					`${componentName}.client.tsx`,
-				);
-
-				const entryContent = `
-import React from 'react';
-import { hydrateRoot } from 'react-dom/client';
-import * as Mod from '${absolutePath}';
-
-const Component = Mod['${componentName}'] || Mod.default;
-
-function hydrate() {
-  const dataElement = document.getElementById("__BUNSTONE_DATA__");
-  const data = dataElement ? JSON.parse(dataElement.textContent || "{}") : {};
-
-  if (typeof document !== 'undefined' && Component) {
-    const root = document.getElementById("root");
-    if (root) {
-      try {
-        hydrateRoot(root, React.createElement(Component, data));
-        console.log('[Bunstone] Hydration successful for component: ${componentName}');
-      } catch (e) {
-        console.error('[Bunstone] Hydration failed for component: ${componentName}', e);
-      }
-    } else {
-      console.error('[Bunstone] Root element "root" not found for hydration.');
-    }
-  } else {
-    console.error('[Bunstone] Component ${componentName} not found in bundle.');
-  }
-}
-
-// Ensure DOM is fully loaded before hydrating
-if (document.readyState === 'loading') {
-  document.addEventListener('DOMContentLoaded', hydrate);
-} else {
-  hydrate();
-}
-        `;
-
-				await Bun.write(entryPath, entryContent);
-
-				const bundleName = `${componentName.toLowerCase()}.bundle.js`;
-				await AppStartup.bundle(entryPath, bundleName);
-				AppStartup.viewBundles.set(componentName, bundleName);
-				AppStartup.viewBundles.set(componentName.toLowerCase(), bundleName);
-			}
-		}
-	}
-
 	/**
 	 * Starts the server on the specified port.
 	 * @param port The port number to listen on.
@@ -426,16 +303,10 @@ if (document.readyState === 'loading') {
 			}
 
 			const componentName = component.name || component.displayName;
-			const bundle =
-				result?.bundle ||
-				AppStartup.viewBundles.get(componentName) ||
-				AppStartup.viewBundles.get(componentName.toLowerCase());
+			const bundleName = `${componentName.toLowerCase()}.bundle.js`;
+			const bundle = `/public/${bundleName}`;
 
-			AppStartup.logger.log(
-				`Rendering component: ${componentName}, bundle found: ${
-					bundle || "none"
-				}`,
-			);
+			AppStartup.logger.log(`Rendering component: ${componentName}`);
 
 			if (!bundle) {
 				AppStartup.logger.warn(

package/lib/utils/bundler.ts

@@ -0,0 +1,184 @@
+import { statSync } from "node:fs";
+import { mkdir, readdir } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
+import { cwd } from "./cwd";
+import { Logger } from "./logger";
+
+export class Bundler {
+	private static logger = new Logger("Bundler");
+
+	static async buildViews(viewsDir: string, outDir: string = "./public") {
+		const viewsDirAbs = resolve(viewsDir);
+		const viewsDirStat = statSync(viewsDirAbs, { throwIfNoEntry: false });
+		if (!viewsDirStat || !viewsDirStat.isDirectory()) return;
+
+		const bunstoneDir = join(cwd(), ".bunstone");
+		const bunstoneDirExists = await Bun.file(bunstoneDir).exists();
+		if (!bunstoneDirExists) {
+			await mkdir(bunstoneDir, { recursive: true });
+		}
+
+		const files = await Bundler.getFilesRecursively(viewsDirAbs);
+		Bundler.logger.log(
+			`Auto-bundling views from ${viewsDirAbs} (${files.length} views found)`,
+		);
+
+		for (const absolutePath of files) {
+			if (absolutePath.endsWith(".tsx") || absolutePath.endsWith(".jsx")) {
+				const componentName = basename(absolutePath, extname(absolutePath));
+				const entryPath = join(bunstoneDir, `${componentName}.client.tsx`);
+				const bundleName = `${componentName.toLowerCase()}.bundle.js`;
+
+				const entryContent = Bundler.generateHydrationEntry(
+					absolutePath,
+					componentName,
+				);
+				await Bun.write(entryPath, entryContent);
+
+				await Bundler.bundleView(entryPath, outDir, bundleName);
+			}
+		}
+	}
+
+	private static async bundleView(
+		entryPath: string,
+		outdir: string,
+		outputName: string,
+	) {
+		try {
+			const result = await Bun.build({
+				entrypoints: [entryPath],
+				outdir: outdir,
+				naming: outputName,
+				minify: true,
+				external: [
+					"react",
+					"react-dom",
+					"react-dom/client",
+					"react/jsx-runtime",
+					"react/jsx-dev-runtime",
+				],
+			});
+
+			if (!result.success) {
+				Bundler.logger.error(
+					`Bundle failed for ${outputName}: ${result.logs
+						.map((l) => l.message)
+						.join("\n")}`,
+				);
+			} else {
+				Bundler.logger.log(
+					`Bundle created successfully: ${outdir}/${outputName}`,
+				);
+			}
+		} catch (error: any) {
+			Bundler.logger.error(
+				`Error during bundling ${outputName}: ${error.message}`,
+			);
+		}
+	}
+
+	private static async getFilesRecursively(dir: string): Promise<string[]> {
+		let results: string[] = [];
+		const list = await readdir(dir);
+		for (const file of list) {
+			const fullPath = join(dir, file);
+			const stat = statSync(fullPath);
+			if (stat?.isDirectory()) {
+				results = results.concat(await Bundler.getFilesRecursively(fullPath));
+			} else {
+				results.push(resolve(fullPath));
+			}
+		}
+		return results;
+	}
+
+	private static generateHydrationEntry(path: string, name: string) {
+		return `
+import React from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import * as Mod from '${path}';
+
+const Component = Mod['${name}'] || Mod.default;
+
+function hydrate() {
+  const dataElement = document.getElementById("__BUNSTONE_DATA__");
+  const data = dataElement ? JSON.parse(dataElement.textContent || "{}") : {};
+
+  if (typeof document !== 'undefined' && Component) {
+    const root = document.getElementById("root");
+    if (root) {
+      try {
+        hydrateRoot(root, React.createElement(Component, data));
+        console.log('[Bunstone] Hydration successful for component: ${name}');
+      } catch (e) {
+        console.error('[Bunstone] Hydration failed for component: ${name}', e);
+      }
+    } else {
+      console.error('[Bunstone] Root element "root" not found for hydration.');
+    }
+  } else {
+    console.error('[Bunstone] Component ${name} not found in bundle.');
+  }
+}
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', hydrate);
+} else {
+  hydrate();
+}
+`;
+	}
+
+	static async buildApp(
+		entrypoint: string,
+		outdir: string = "./dist",
+		compile: boolean = false,
+	) {
+		const entryAbs = resolve(entrypoint);
+		if (!(await Bun.file(entryAbs).exists())) {
+			throw new Error(`Entrypoint not found: ${entrypoint}`);
+		}
+
+		Bundler.logger.log(`Building application from ${entrypoint}...`);
+
+		if (compile) {
+			const result = await Bun.spawn(
+				[
+					"bun",
+					"build",
+					entrypoint,
+					"--compile",
+					"--outfile",
+					join(outdir, "app"),
+				],
+				{
+					stdout: "inherit",
+					stderr: "inherit",
+				},
+			);
+			const exitCode = await result.exited;
+			if (exitCode !== 0) {
+				throw new Error("Compilation failed");
+			}
+		} else {
+			const result = await Bun.build({
+				entrypoints: [entrypoint],
+				outdir: outdir,
+				target: "bun",
+				minify: true,
+				sourcemap: "external",
+				external: ["react", "react-dom", "elysia", "@elysiajs/*"],
+			});
+
+			if (!result.success) {
+				Bundler.logger.error(
+					"Build failed:",
+					result.logs.map((l) => l.message).join("\n"),
+				);
+				throw new Error("Application build failed");
+			}
+			Bundler.logger.log(`Application built successfully to ${outdir}`);
+		}
+	}
+}

package/package.json

@@ -13,7 +13,7 @@
       "types": "./dist/*.d.ts"
     }
   },
-  "version": "0.5.1",
+  "version": "0.5.2",
   "homepage": "https://bunstone.diario.one/",
   "repository": {
     "url": "https://github.com/diariodaregiao/bunstone.git",

package/starter/package.json

@@ -4,8 +4,9 @@
   "main": "src/main.ts",
   "type": "module",
   "scripts": {
-    "start": "bun run src/main.ts",
-    "dev": "bun --watch src/main.ts",
+    "start": "bun run dist/index.js",
+    "dev": "bunstone run --watch src/main.ts",
+    "build": "bunstone build src/main.ts",
     "test": "bun test",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",