hightjs 0.3.2 → 0.3.4

package/src/client/entry.client.tsx

@@ -284,7 +284,7 @@ function initializeClient() {
     const initialData = (window as any).__HWEB_INITIAL_DATA__;
 
     if (!initialData) {
-        console.error('[hweb] Dados iniciais não encontrados na página.');
+        console.error('[hweb] Initial data not found on page.');
         return;
     }
 
@@ -298,7 +298,7 @@ function initializeClient() {
 
     const container = document.getElementById('root');
     if (!container) {
-        console.error('[hweb] Container #root não encontrado.');
+        console.error('[hweb] Container #root not found.');
         return;
     }
 
@@ -316,7 +316,7 @@ function initializeClient() {
             />
         );
     } catch (error) {
-        console.error('[hweb] Erro ao renderizar aplicação:', error);
+        console.error('[hweb] Error rendering application:', error);
     }
 }
 

package/src/helpers.ts

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 /*
  * This file is part of the HightJS Project.
  * Copyright (c) 2025 itsmuzin
@@ -19,9 +21,10 @@
 import http, {IncomingMessage, Server, ServerResponse} from 'http';
 import os from 'os';
 import {URLSearchParams} from 'url'; // API moderna, substitui 'querystring'
+import path from 'path';
 // Helpers para integração com diferentes frameworks
 import hweb, {FrameworkAdapterFactory} from './index'; // Importando o tipo
-import type {HightJSOptions} from './types';
+import type {HightJSOptions, HightConfig, HightConfigFunction} from './types';
 import Console, {Colors} from "./api/console";
 import https, { Server as HttpsServer } from 'https'; // <-- ADICIONAR
 import fs from 'fs'; // <-- ADICIONAR
@@ -66,7 +69,7 @@ function getLocalExternalIp(): string {
 }
 
 const sendBox = (options: HightJSOptions) => {
-    const isDev = options.dev ? "Rodando em modo de desenvolvimento" : null;
+    const isDev = options.dev ? "Running in development mode" : null;
 
     // 1. Verifica se o SSL está ativado (baseado na mesma lógica do initNativeServer)
     const isSSL = options.ssl && options.ssl.key && options.ssl.cert;
@@ -75,12 +78,12 @@ const sendBox = (options: HightJSOptions) => {
 
     // 2. Monta as mensagens com o protocolo correto
     const messages = [
-        ` ${Colors.FgGray}┃${Colors.Reset} Local: ${Colors.FgGreen}${protocol}://localhost:${options.port}${Colors.Reset}`,
+        ` ${Colors.FgGray}┃${Colors.Reset} Local:    ${Colors.FgGreen}${protocol}://localhost:${options.port}${Colors.Reset}`,
     ];
 
     // Só adiciona a rede se o IP local for encontrado
     if (localIp) {
-        messages.push(` ${Colors.FgGray}┃${Colors.Reset} Rede:  ${Colors.FgGreen}${protocol}://${localIp}:${options.port}${Colors.Reset}`);
+        messages.push(` ${Colors.FgGray}┃${Colors.Reset} Network:  ${Colors.FgGreen}${protocol}://${localIp}:${options.port}${Colors.Reset}`);
     }
 
     if (isDev) {
@@ -89,10 +92,78 @@ const sendBox = (options: HightJSOptions) => {
 
     // Adiciona aviso de redirecionamento se estiver em modo SSL
     if (isSSL && options.ssl?.redirectPort) {
-        messages.push(` ${Colors.FgGray}┃${Colors.Reset} HTTP (porta ${options.ssl?.redirectPort}) está redirecionando para HTTPS.`);
+        messages.push(` ${Colors.FgGray}┃${Colors.Reset} HTTP (port ${options.ssl?.redirectPort}) is redirecting to HTTPS.`);
     }
 
-    Console.box(messages.join("\n"), { title: "Acesse em:" });
+    Console.box(messages.join("\n"), { title: "Access on:" });
+}
+
+/**
+ * Carrega o arquivo de configuração hightjs.config.ts ou hightjs.config.js do projeto
+ * @param projectDir Diretório raiz do projeto
+ * @param phase Fase de execução ('development' ou 'production')
+ * @returns Configuração mesclada com os valores padrão
+ */
+async function loadHightConfig(projectDir: string, phase: string): Promise<HightConfig> {
+    const defaultConfig: HightConfig = {
+        maxHeadersCount: 100,
+        headersTimeout: 60000,
+        requestTimeout: 30000,
+        serverTimeout: 35000,
+        individualRequestTimeout: 30000,
+        maxUrlLength: 2048,
+    };
+
+    try {
+        // Tenta primeiro .ts, depois .js
+        const possiblePaths = [
+            path.join(projectDir, 'hightjs.config.ts'),
+            path.join(projectDir, 'hightjs.config.js'),
+        ];
+
+        let configPath: string | null = null;
+        for (const p of possiblePaths) {
+            if (fs.existsSync(p)) {
+                configPath = p;
+                break;
+            }
+        }
+
+        if (!configPath) {
+            return defaultConfig;
+        }
+
+        // Remove do cache para permitir hot reload da configuração em dev
+        delete require.cache[require.resolve(configPath)];
+
+        const configModule = require(configPath);
+        const configExport = configModule.default || configModule;
+
+        let userConfig: HightConfig;
+
+        if (typeof configExport === 'function') {
+            // Suporta tanto função síncrona quanto assíncrona
+            userConfig = await Promise.resolve(
+                (configExport as HightConfigFunction)(phase, { defaultConfig })
+            );
+        } else {
+            userConfig = configExport;
+        }
+
+        // Mescla a configuração do usuário com a padrão
+        const mergedConfig = { ...defaultConfig, ...userConfig };
+
+        const configFileName = path.basename(configPath);
+        Console.info(`${Colors.FgCyan}[Config]${Colors.Reset} Loaded ${configFileName}`);
+
+        return mergedConfig;
+    } catch (error) {
+        if (error instanceof Error) {
+            Console.warn(`${Colors.FgYellow}[Config]${Colors.Reset} Error loading hightjs.config: ${error.message}`);
+            Console.warn(`${Colors.FgYellow}[Config]${Colors.Reset} Using default configuration`);
+        }
+        return defaultConfig;
+    }
 }
 
 /**
@@ -181,8 +252,14 @@ async function initNativeServer(hwebApp: HWebApp, options: HightJSOptions, port:
     const time = Date.now();
 
     await hwebApp.prepare();
+
+    // Carrega a configuração do arquivo hightjs.config.js
+    const projectDir = options.dir || process.cwd();
+    const phase = options.dev ? 'development' : 'production';
+    const hightConfig = await loadHightConfig(projectDir, phase);
+
     const handler = hwebApp.getRequestHandler();
-    const msg = Console.dynamicLine(`    ${Colors.BgYellow} ready ${Colors.Reset}  ${Colors.Bright}Iniciando HightJS na porta ${options.port}${Colors.Reset}`);
+    const msg = Console.dynamicLine(`    ${Colors.BgYellow} ready ${Colors.Reset}  ${Colors.Bright}Starting HightJS on port ${options.port}${Colors.Reset}`);
 
     // --- LÓGICA DO LISTENER (REUTILIZÁVEL) ---
     // Extraímos a lógica principal para uma variável
@@ -200,16 +277,17 @@ async function initNativeServer(hwebApp: HWebApp, options: HightJSOptions, port:
             res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
         }
 
-        // Timeout por requisição
-        req.setTimeout(30000, () => {
+        // Timeout por requisição (usa configuração personalizada)
+        req.setTimeout(hightConfig.individualRequestTimeout || 30000, () => {
             res.statusCode = 408; // Request Timeout
             res.end('Request timeout');
         });
 
         try {
-            // Validação básica de URL
+            // Validação básica de URL (usa configuração personalizada)
             const url = req.url || '/';
-            if (url.length > 2048) {
+            const maxUrlLength = hightConfig.maxUrlLength || 2048;
+            if (url.length > maxUrlLength) {
                 res.statusCode = 414; // URI Too Long
                 res.end('URL too long');
                 return;
@@ -227,9 +305,9 @@ async function initNativeServer(hwebApp: HWebApp, options: HightJSOptions, port:
         } catch (error) {
             // Log do erro no servidor
             if (error instanceof Error) {
-                Console.error(`Erro no servidor nativo: ${error.message}`);
+                Console.error(`Native server error: ${error.message}`);
             } else {
-                Console.error('Erro desconhecido no servidor nativo:', error);
+                Console.error('Unknown native server error:', error);
             }
 
             // Tratamento de erro (idêntico ao seu original)
@@ -297,15 +375,15 @@ async function initNativeServer(hwebApp: HWebApp, options: HightJSOptions, port:
         server = http.createServer(requestListener as any); // (any para contornar HWebIncomingMessage)
     }
 
-    // Configurações de segurança do servidor (Comum a ambos)
-    server.setTimeout(35000); // Timeout geral do servidor
-    server.maxHeadersCount = 100; // Limita número de headers
-    server.headersTimeout = 60000; // Timeout para headers
-    server.requestTimeout = 30000; // Timeout para requisições
+    // Configurações de segurança do servidor (usa configuração personalizada)
+    server.setTimeout(hightConfig.serverTimeout || 35000); // Timeout geral do servidor
+    server.maxHeadersCount = hightConfig.maxHeadersCount || 100; // Limita número de headers
+    server.headersTimeout = hightConfig.headersTimeout || 60000; // Timeout para headers
+    server.requestTimeout = hightConfig.requestTimeout || 30000; // Timeout para requisições
 
     server.listen(port, hostname, () => {
         sendBox({ ...options, port });
-        msg.end(`  ${Colors.BgGreen} ready ${Colors.Reset}    ${Colors.Bright}Pronto na porta ${Colors.BgGreen} ${options.port} ${Colors.Reset}${Colors.Bright} em ${Date.now() - time}ms${Colors.Reset}\n`);
+        msg.end(`  ${Colors.BgGreen} ready ${Colors.Reset}    ${Colors.Bright}Ready on port ${Colors.BgGreen} ${options.port} ${Colors.Reset}${Colors.Bright} in ${Date.now() - time}ms${Colors.Reset}\n`);
     });
 
     // Configura WebSocket para hot reload (Comum a ambos)
@@ -344,7 +422,7 @@ export function app(options: HightJSOptions = {}) {
                     const cookieParser = require('cookie-parser');
                     serverApp.use(cookieParser());
                 } catch (e) {
-                    Console.error("Não foi possivel achar cookie-parser");
+                    Console.error("Could not find cookie-parser");
                 }
                 serverApp.use(express.json());
                 serverApp.use(express.urlencoded({ extended: true }));
@@ -355,12 +433,12 @@ export function app(options: HightJSOptions = {}) {
                 try {
                     await serverApp.register(require('@fastify/cookie'));
                 } catch (e) {
-                    Console.error("Não foi possivel achar @fastify/cookie");
+                    Console.error("Could not find @fastify/cookie");
                 }
                 try {
                     await serverApp.register(require('@fastify/formbody'));
                 } catch (e) {
-                    Console.error("Não foi possivel achar @fastify/formbody");
+                    Console.error("Could not find @fastify/formbody");
                 }
                 await serverApp.register(async (fastify: any) => {
                     fastify.all('*', handler);
@@ -390,7 +468,7 @@ export function app(options: HightJSOptions = {}) {
                     const data = await response.json();
                     return data.version;
                 } catch (error) {
-                    Console.error('Não foi possível verificar a versão mais recente do HightJS:', error);
+                    Console.error('Could not check for the latest HightJS version:', error);
                     return currentVersion; // Retorna a versão atual em caso de erro
                 }
             }
@@ -398,23 +476,21 @@ export function app(options: HightJSOptions = {}) {
             const isUpToDate = latestVersion === currentVersion;
             let message;
             if (!isUpToDate) {
-                message = `${Colors.FgGreen}   Há uma nova versão disponível (v${latestVersion})${Colors.FgMagenta}`
+                message = `${Colors.FgGreen}   A new version is available (v${latestVersion})${Colors.FgMagenta}`
             } else {
-                message = `${Colors.FgGreen}   Você está na versão mais recente${Colors.FgMagenta}`
+                message = `${Colors.FgGreen}   You are on the latest version${Colors.FgMagenta}`
             }
             console.log(`${Colors.FgMagenta}
             __       ___ ${Colors.FgGreen}      __  ${Colors.FgMagenta}
     |__| | / _\` |__|  |  ${Colors.FgGreen}   | /__\` ${Colors.FgMagenta}   ${Colors.FgMagenta}HightJS ${Colors.FgGray}(v${require('../package.json').version}) - itsmuzin${Colors.FgMagenta}
-    |  | | \\__> |  |  |  ${Colors.FgGreen}\\__/ .__/ ${message}
-                               
-                               
+    |  | | \\__> |  |  |  ${Colors.FgGreen}\\__/ .__/ ${message}        
               ${Colors.Reset}`);
 
             const actualPort = options.port || 3000;
             const actualHostname = options.hostname || "0.0.0.0";
 
             if (framework !== 'native') {
-                Console.warn(`O framework "${framework}" foi selecionado, mas o método init() só funciona com o framework "native". Iniciando servidor nativo...`);
+                Console.warn(`The "${framework}" framework was selected, but the init() method only works with the "native" framework. Starting native server...`);
             }
 
 

package/src/hotReload.ts

@@ -39,6 +39,8 @@ export class HotReloadManager {
     private isShuttingDown: boolean = false;
     private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
     private customHotReloadListener: ((file: string) => Promise<void> | void) | null = null;
+    private isBuilding: boolean = false;
+    private buildCompleteResolve: (() => void) | null = null;
 
     constructor(projectDir: string) {
         this.projectDir = projectDir;
@@ -200,33 +202,48 @@ export class HotReloadManager {
         clearFileCache(filePath);
         this.clearBackendCache(filePath);
 
-        // Checa build se for .ts/.tsx/.js/.jsx
-        const ext = path.extname(filePath);
-        if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
-            const result = await this.checkFrontendBuild(filePath);
-            if (result.error) {
-                this.notifyClients('src-error', { file: filePath, error: result.error });
-                return;
-            }
-        }
-
-        // Se for arquivo de frontend, notifica o cliente para recarregar a página
+        // Se for arquivo de frontend, aguarda o build terminar antes de recarregar
         if (isFrontendFile) {
-            Console.logWithout(Levels.INFO, Colors.BgRed,`📄 Recarregando frontend...`);
-            this.frontendChangeCallback?.();
-            this.notifyClients('frontend-reload', { file: filePath, event: 'change' });
+            Console.logWithout(Levels.INFO, Colors.BgRed,`📄 Waiting for frontend build...`);
+
+            // Marca que estamos esperando um build
+            this.isBuilding = true;
+
+            // Cria uma promise que será resolvida quando o build terminar
+            const buildPromise = new Promise<void>((resolve) => {
+                this.buildCompleteResolve = resolve;
+            });
+
+            // Aguarda o build terminar (com timeout de 30 segundos)
+            const timeoutPromise = new Promise<void>((_, reject) => {
+                setTimeout(() => reject(new Error('Build timeout')), 30000);
+            });
+
+            try {
+                await Promise.race([buildPromise, timeoutPromise]);
+                Console.logWithout(Levels.INFO, Colors.BgRed,`✅ Build complete, reloading frontend...`);
+                this.frontendChangeCallback?.();
+                this.notifyClients('frontend-reload', { file: filePath, event: 'change' });
+            } catch (error) {
+                Console.logWithout(Levels.ERROR, Colors.BgRed,`⚠️ Timeout in build, reloading anyway...`);
+                this.frontendChangeCallback?.();
+                this.notifyClients('frontend-reload', { file: filePath, event: 'change' });
+            } finally {
+                this.isBuilding = false;
+                this.buildCompleteResolve = null;
+            }
         }
 
         // Se for arquivo de backend, recarrega o módulo e notifica
         if (isBackendFile) {
-            Console.logWithout(Levels.INFO, Colors.BgRed,`⚙️ Recarregando backend...`);
+            Console.logWithout(Levels.INFO, Colors.BgRed,`⚙️ Reloading backend...`);
             this.backendApiChangeCallback?.();
             this.notifyClients('backend-api-reload', { file: filePath, event: 'change' });
         }
 
         // Fallback: se não for nem frontend nem backend detectado, recarrega tudo
         if (!isFrontendFile && !isBackendFile) {
-            Console.logWithout(Levels.INFO, Colors.BgRed,`🔄 Recarregando aplicação...`);
+            Console.logWithout(Levels.INFO, Colors.BgRed,`🔄 Reloading application...`);
             this.frontendChangeCallback?.();
             this.backendApiChangeCallback?.();
             this.notifyClients('src-reload', { file: filePath, event: 'change' });
@@ -238,7 +255,7 @@ export class HotReloadManager {
                 await this.customHotReloadListener(filePath);
             } catch (error) {
                 // @ts-ignore
-                Console.logWithout(Levels.ERROR, `Erro no listener customizado: ${error.message}`);
+                Console.logWithout(Levels.ERROR, `Error in custom listener: ${error.message}`);
             }
         }
     }
@@ -256,7 +273,7 @@ export class HotReloadManager {
                 try {
                     ws.send(message);
                 } catch (error) {
-                    Console.logWithout(Levels.ERROR, Colors.BgRed, `Erro ao enviar mensagem WebSocket: ${error}`);
+                    Console.logWithout(Levels.ERROR, Colors.BgRed, `Error sending WebSocket message: ${error}`);
                     deadClients.push(ws);
                 }
             } else {
@@ -325,7 +342,7 @@ export class HotReloadManager {
                         ws = new WebSocket('ws://localhost:3000/hweb-hotreload/');
                         
                         ws.onopen = function() {
-                            console.log('🔌 Hot-reload conectado');
+                            console.log('🔌 Hot-reload connected');
                             isConnected = true;
                             reconnectAttempts = 0;
                             reconnectInterval = 1000;
@@ -345,13 +362,13 @@ export class HotReloadManager {
                                         window.location.reload();
                                         break;
                                     case 'server-restart':
-                                        console.log('🔄 Servidor reiniciando...');
+                                        console.log('🔄 Server restarting...');
                                         break;
                                     case 'server-ready':
                                         setTimeout(() => window.location.reload(), 500);
                                         break;
                                     case 'frontend-error':
-                                        console.error('❌ Erro no frontend:', message.data);
+                                        console.error('❌ Frontend error:', message.data);
                                         break;
                                 }
                             } catch (e) {
@@ -376,7 +393,7 @@ export class HotReloadManager {
                         };
                         
                     } catch (error) {
-                        console.error('Erro ao criar WebSocket:', error);
+                        console.error('Error creating WebSocket:', error);
                         scheduleReconnect();
                     }
                 }
@@ -446,45 +463,18 @@ export class HotReloadManager {
 
     setHotReloadListener(listener: (file: string) => Promise<void> | void) {
         this.customHotReloadListener = listener;
-        Console.info('🔌 Hot reload listener customizado registrado');
+        Console.info('🔌 Hot reload custom listener registered');
     }
 
     removeHotReloadListener() {
         this.customHotReloadListener = null;
     }
 
-    private async checkFrontendBuild(filePath: string) {
-        try {
-            const tsNodePath = require.resolve('ts-node');
-            const { spawn } = require('child_process');
-
-            return new Promise<{ error?: string }>((resolve) => {
-                const proc = spawn(process.execPath, [tsNodePath, '--transpile-only', filePath], {
-                    cwd: this.projectDir,
-                    env: process.env,
-                    timeout: 10000 // Timeout de 10 segundos
-                });
-
-                let errorMsg = '';
-
-                proc.stderr.on('data', (data: Buffer) => {
-                    errorMsg += data.toString();
-                });
-
-                proc.on('close', (code: number) => {
-                    if (code !== 0 && errorMsg) {
-                        resolve({ error: errorMsg });
-                    } else {
-                        resolve({});
-                    }
-                });
-
-                proc.on('error', (error: Error) => {
-                    resolve({ error: error.message });
-                });
-            });
-        } catch (error) {
-            return { error: `Erro ao verificar build: ${error}` };
+    onBuildComplete(success: boolean) {
+        if (this.buildCompleteResolve) {
+            this.buildCompleteResolve();
+            this.buildCompleteResolve = null;
         }
+        this.isBuilding = false;
     }
 }

package/src/index.ts

@@ -61,6 +61,9 @@ export { app } from './helpers';
 // Exporta o sistema de WebSocket
 export type { WebSocketContext, WebSocketHandler } from './types';
 
+// Exporta os tipos de configuração
+export type { HightConfig, HightConfigFunction } from './types';
+
 // Função para verificar se o projeto é grande o suficiente para se beneficiar de chunks
 function isLargeProject(projectDir: string): boolean {
     try {
@@ -254,7 +257,7 @@ export default function hweb(options: HightJSOptions) {
 
                 // Adiciona callback para recarregar TUDO quando qualquer arquivo mudar
                 hotReloadManager.onBackendApiChange(() => {
-                    Console.info('🔄 Recarregando backend e dependências...');
+
 
                     loadBackendRoutes(userBackendRoutesDir);
                     processWebSocketRoutes(); // Processa rotas WS após recarregar backend
@@ -262,18 +265,16 @@ export default function hweb(options: HightJSOptions) {
 
                 // Adiciona callback para regenerar entry file quando frontend mudar
                 hotReloadManager.onFrontendChange(() => {
-                    Console.info('🔄 Regenerando frontend...');
                     regenerateEntryFile();
                 });
             }
             const now = Date.now();
-            const timee = Console.dynamicLine(`  ${Colors.BgYellow} router ${Colors.Reset}   Carregando rotas e componentes do frontend e backend`);
+            const timee = Console.dynamicLine(`  ${Colors.BgYellow} router ${Colors.Reset}   Loading routes and components`);
             const spinnerFrames1 = ['|', '/', '-', '\\'];
             let frameIndex1 = 0;
 
             const spinner1 = setInterval(() => {
-                Console.info('aaaa')
-                timee.update(`   ${Colors.FgYellow}${spinnerFrames1[frameIndex1]}${Colors.Reset}  Carregando rotas e componentes...`);
+                timee.update(`   ${Colors.FgYellow}${spinnerFrames1[frameIndex1]}${Colors.Reset}  Loading routes and components...`);
                 frameIndex1 = (frameIndex1 + 1) % spinnerFrames1.length;
             }, 100); // muda a cada 100ms
             // ORDEM IMPORTANTE: Carrega TUDO antes de criar o arquivo de entrada
@@ -293,18 +294,18 @@ export default function hweb(options: HightJSOptions) {
 
             entryPoint = createEntryFile(dir, frontendRoutes);
             clearInterval(spinner1)
-            timee.end(`  ${Colors.BgGreen} router ${Colors.Reset}   Rotas e componentes carregados em ${Date.now() - now}ms`);
+            timee.end(`  ${Colors.BgGreen} router ${Colors.Reset}   Routes and components loaded in ${Date.now() - now}ms`);
 
 
             if (isProduction) {
-                const time = Console.dynamicLine(`  ${Colors.BgYellow} build ${Colors.Reset}    Iniciando build do cliente para produção`);
+                const time = Console.dynamicLine(`  ${Colors.BgYellow} build ${Colors.Reset}    Starting client build`);
 
 // Spinner
                 const spinnerFrames = ['|', '/', '-', '\\'];
                 let frameIndex = 0;
 
                 const spinner = setInterval(() => {
-                    time.update(`    ${Colors.FgYellow}${spinnerFrames[frameIndex]}${Colors.Reset}  Buildando para produção...`);
+                    time.update(`    ${Colors.FgYellow}${spinnerFrames[frameIndex]}${Colors.Reset}  Building...`);
                     frameIndex = (frameIndex + 1) % spinnerFrames.length;
                 }, 100); // muda a cada 100ms
 
@@ -314,14 +315,14 @@ export default function hweb(options: HightJSOptions) {
 
                 clearInterval(spinner); // para o spinner
                 time.update(""); // limpa a linha
-                time.end(`  ${Colors.BgGreen} build ${Colors.Reset}    Build do cliente concluído em ${elapsed}ms`);
+                time.end(`  ${Colors.BgGreen} build ${Colors.Reset}    Client build completed in ${elapsed}ms`);
 
             } else {
-                const time = Console.dynamicLine(`  ${Colors.BgYellow} watcher ${Colors.Reset}  Iniciando watch do cliente`);
+                const time = Console.dynamicLine(`  ${Colors.BgYellow} watcher ${Colors.Reset}  Starting client watch`);
                 watchWithChunks(entryPoint, outDir, hotReloadManager!).catch(err => {
-                    Console.error(`Erro ao iniciar o watch`, err);
+                    Console.error(`Error starting watch`, err);
                 });
-                time.end(`  ${Colors.BgGreen} watcher ${Colors.Reset}  Watch do cliente iniciado`);
+                time.end(`  ${Colors.BgGreen} watcher ${Colors.Reset}  Client Watch started`);
             }
 
         },
@@ -339,7 +340,6 @@ export default function hweb(options: HightJSOptions) {
                 if (instrumentation.hotReloadListener && typeof instrumentation.hotReloadListener === 'function') {
                     if (hotReloadManager) {
                         hotReloadManager.setHotReloadListener(instrumentation.hotReloadListener);
-                        Console.info('✅ Hot reload listener registrado');
                     }
                 }
 
@@ -348,7 +348,7 @@ export default function hweb(options: HightJSOptions) {
                 } else if (typeof instrumentation.default === 'function') {
                     instrumentation.default();
                 } else {
-                    Console.warn(`O arquivo de instrumentação ${instrumentationFile} não exporta uma função padrão.`);
+                    Console.warn(`The instrumentation file ${instrumentationFile} does not export a default function.`);
                 }
             }
         },
@@ -470,8 +470,8 @@ export default function hweb(options: HightJSOptions) {
                             return;
                         }
                     } catch (error) {
-                        Console.error(`Erro na rota de API ${pathname}:`, error);
-                        genericRes.status(500).text('Erro interno do servidor na API');
+                        Console.error(`API route error ${pathname}:`, error);
+                        genericRes.status(500).text('Internal server error in API');
                         return;
                     }
                 }
@@ -498,8 +498,8 @@ export default function hweb(options: HightJSOptions) {
                         genericRes.status(404).header('Content-Type', 'text/html').send(html);
                         return;
                     } catch (error) {
-                        Console.error(`Erro ao renderizar página 404:`, error);
-                        genericRes.status(404).text('Página não encontrada');
+                        Console.error(`Error rendering page 404:`, error);
+                        genericRes.status(404).text('Page not found');
                         return;
                     }
                 }
@@ -513,8 +513,8 @@ export default function hweb(options: HightJSOptions) {
                     });
                     genericRes.status(200).header('Content-Type', 'text/html').send(html);
                 } catch (error) {
-                    Console.error(`Erro ao renderizar a página ${pathname}:`, error);
-                    genericRes.status(500).text('Erro interno do servidor');
+                    Console.error(`Error rendering page ${pathname}:`, error);
+                    genericRes.status(500).text('Internal server error');
                 }
             };
         },
@@ -529,19 +529,6 @@ export default function hweb(options: HightJSOptions) {
             setupWebSocketUpgrade(actualServer, hotReloadManager);
         },
 
-        build: async () => {
-            const msg = Console.dynamicLine(`  ${Colors.FgYellow}●  ${Colors.Reset}Iniciando build do cliente para produção`);
-            const outDir = path.join(dir, 'hweb-dist');
-            fs.mkdirSync(outDir, {recursive: true});
-
-            const routes = loadRoutes(userWebRoutesDir);
-            const entryPoint = createEntryFile(dir, routes);
-            const outfile = path.join(outDir, 'main.js');
-
-            await build(entryPoint, outfile, true); // Força produção no build manual
-
-            msg.end(`  ${Colors.FgGreen}●  ${Colors.Reset}Build do cliente concluído: ${outfile}`);
-        },
 
         stop: () => {
             if (hotReloadManager) {