vatts 1.0.2-alpha.1 → 1.0.2-alpha.3

package/dist/builder.js

@@ -58,14 +58,14 @@ const markdownPlugin = () => {
             if (id.endsWith('.md')) {
                 return {
                     code: `export default ${JSON.stringify(code)};`,
-                    map: null
+                    map: null // Null map economiza memória se não precisa debugar markdown
                 };
             }
         }
     };
 };
 /**
- * Plugin para CSS/PostCSS Manual (Smart Extraction + Tailwind Fix)
+ * Plugin para CSS/PostCSS Manual (Otimizado para RAM)
  */
 const customPostCssPlugin = (isProduction) => {
     let cachedProcessor = null;
@@ -95,7 +95,9 @@ const customPostCssPlugin = (isProduction) => {
                     }
                 }
                 if (postcss) {
-                    delete require.cache[require.resolve(configPath)];
+                    // OTIMIZAÇÃO DE RAM: Removido 'delete require.cache'.
+                    // Limpar o cache constantemente fragmenta a memória heap do V8 em processos longos (watch).
+                    // Se o usuário alterar o config, ele deve reiniciar o processo.
                     const config = require(configPath);
                     const postcssConfig = config.default || config;
                     const plugins = [];
@@ -174,36 +176,24 @@ const customPostCssPlugin = (isProduction) => {
                         Console.warn(`PostCSS process error:`, e.message);
                     }
                 }
-                // ESTRATÉGIA DE EXTRAÇÃO INTELIGENTE
-                if (isProduction) {
-                    // Emite arquivo físico (Melhora Cache e Tamanho do JS)
-                    const referenceId = this.emitFile({
-                        type: 'asset',
-                        name: path.basename(filePath),
-                        source: processedCss
-                    });
-                    // Retorna código JS que auto-injeta o <link>
-                    // Isso mantém compatibilidade (não quebra o app) mas usa arquivo externo
-                    return `
-                        const cssUrl = import.meta.ROLLUP_FILE_URL_${referenceId};
-                        if (typeof document !== 'undefined') {
-                            const link = document.createElement('link');
-                            link.rel = 'stylesheet';
-                            link.href = cssUrl;
-                            document.head.appendChild(link);
-                        }
-                        export default cssUrl;
-                    `;
-                }
-                // Modo DEV (Inline para Hot Reload mais rápido)
+                // OTIMIZAÇÃO: Emite arquivo físico sempre que possível.
+                // Strings gigantes de CSS inline consomem muita RAM no bundle JS.
+                const referenceId = this.emitFile({
+                    type: 'asset',
+                    name: path.basename(filePath),
+                    source: processedCss
+                });
+                // Lógica unificada: Usa arquivo externo tanto em Dev quanto Prod.
+                // Isso libera a memória que seria usada para stringificar o CSS dentro do JS.
                 return `
-                    const css = ${JSON.stringify(processedCss)};
+                    const cssUrl = import.meta.ROLLUP_FILE_URL_${referenceId};
                     if (typeof document !== 'undefined') {
-                        const style = document.createElement('style');
-                        style.textContent = css;
-                        document.head.appendChild(style);
+                        const link = document.createElement('link');
+                        link.rel = 'stylesheet';
+                        link.href = cssUrl;
+                        document.head.appendChild(link);
                     }
-                    export default css;
+                    export default cssUrl;
                 `;
             }
             return null;
@@ -211,12 +201,13 @@ const customPostCssPlugin = (isProduction) => {
     };
 };
 /**
- * Plugin Inteligente para Assets (Substitui forceBase64Plugin)
- * - Dev: Base64 (Rápido)
- * - Prod: Arquivos > 4KB viram URL (Melhora LCP), < 4KB Base64 (Menos requests)
+ * Plugin Inteligente para Assets (Otimizado para RAM)
+ * - Agora utiliza emissão de arquivos também em DEV para arquivos grandes.
  */
 const smartAssetPlugin = (isProduction) => {
-    const INLINE_LIMIT = 4096; // 4KB
+    // 4KB - Arquivos maiores que isso viram referência externa.
+    // Manter isso baixo economiza MUITA RAM, pois evita strings Base64 gigantes no JS.
+    const INLINE_LIMIT = 4096;
     return {
         name: 'smart-asset-loader',
         async load(id) {
@@ -238,42 +229,23 @@ const smartAssetPlugin = (isProduction) => {
             const type = mimeTypes[ext];
             if (!type)
                 return null;
-            // Text files always strings
+            // Text files always strings (geralmente pequenos)
             if (type === 'txt') {
                 const content = await fs.promises.readFile(cleanId, 'utf8');
                 return `export default ${JSON.stringify(content)};`;
             }
-            const buffer = await fs.promises.readFile(cleanId);
+            let buffer = await fs.promises.readFile(cleanId);
             const size = buffer.length;
-            // MODO PRODUÇÃO: Otimização de Assets
-            if (isProduction) {
-                // SVG: Se for pequeno inlina, se grande emite arquivo
-                if (type === 'svg') {
-                    if (size < INLINE_LIMIT) {
-                        const content = buffer.toString('utf8');
-                        const base64 = buffer.toString('base64');
-                        return `
-                            export default "data:image/svg+xml;base64,${base64}";
-                            export const svgContent = ${JSON.stringify(content)};
-                        `;
-                    }
-                    else {
-                        // Emite arquivo físico
-                        const referenceId = this.emitFile({
-                            type: 'asset',
-                            name: path.basename(cleanId),
-                            source: buffer
-                        });
-                        const content = buffer.toString('utf8');
-                        return `
-                            export default import.meta.ROLLUP_FILE_URL_${referenceId};
-                            export const svgContent = ${JSON.stringify(content)};
-                        `;
-                    }
-                }
-                // Outros assets
+            // Tratamento especial para SVG (inline SVG vs URL)
+            if (type === 'svg') {
                 if (size < INLINE_LIMIT) {
-                    return `export default "data:${type};base64,${buffer.toString('base64')}";`;
+                    const content = buffer.toString('utf8');
+                    const base64 = buffer.toString('base64');
+                    buffer = null; // GC Hint
+                    return `
+                        export default "data:image/svg+xml;base64,${base64}";
+                        export const svgContent = ${JSON.stringify(content)};
+                    `;
                 }
                 else {
                     const referenceId = this.emitFile({
@@ -281,19 +253,32 @@ const smartAssetPlugin = (isProduction) => {
                         name: path.basename(cleanId),
                         source: buffer
                     });
-                    return `export default import.meta.ROLLUP_FILE_URL_${referenceId};`;
+                    const content = buffer.toString('utf8');
+                    buffer = null; // GC Hint
+                    return `
+                        export default import.meta.ROLLUP_FILE_URL_${referenceId};
+                        export const svgContent = ${JSON.stringify(content)};
+                    `;
                 }
             }
-            // MODO DESENVOLVIMENTO: Tudo Base64 para performance de build
-            if (type === 'svg') {
-                const content = buffer.toString('utf8');
+            // Para outros assets:
+            // Se for pequeno, Base64 (reduz requests HTTP)
+            // Se for grande, Arquivo (reduz uso de RAM e tamanho do bundle JS)
+            // Essa lógica agora aplica para DEV e PROD. Base64 em Dev para arquivos grandes era o vilão da RAM.
+            if (size < INLINE_LIMIT) {
                 const base64 = buffer.toString('base64');
-                return `
-                    export default "data:image/svg+xml;base64,${base64}";
-                    export const svgContent = ${JSON.stringify(content)};
-                `;
+                buffer = null; // Libera memória do buffer bruto imediatamente
+                return `export default "data:${type};base64,${base64}";`;
+            }
+            else {
+                const referenceId = this.emitFile({
+                    type: 'asset',
+                    name: path.basename(cleanId),
+                    source: buffer
+                });
+                buffer = null; // Libera memória
+                return `export default import.meta.ROLLUP_FILE_URL_${referenceId};`;
             }
-            return `export default "data:${type};base64,${buffer.toString('base64')}";`;
         }
     };
 };
@@ -303,25 +288,25 @@ const smartAssetPlugin = (isProduction) => {
 function createRollupConfig(entryPoint, outdir, isProduction) {
     return {
         input: entryPoint,
-        // Para evitar bare imports no browser (sem import map), em DEV também bundle React/ReactDOM.
-        // O HMR evita "Invalid hook call" removendo o script antigo e recarregando main.js.
         external: nodeBuiltIns,
-        // Otimização: Em prod usa 'recommended' para limpar código morto
-        treeshake: isProduction ? 'recommended' : false,
-        // CORREÇÃO CRÍTICA: Desativa cache em desenvolvimento (watch mode)
-        // Isso previne que o Rollup emita "sucesso" baseado em um cache obsoleto quando o arquivo ainda tem erro.
+        // Otimização: Treeshake limpa memória removendo nós da AST não usados
+        treeshake: {
+            moduleSideEffects: 'no-external', // Mais agressivo, economiza memória
+            preset: isProduction ? 'recommended' : 'smallest'
+        },
+        // Cache desativado em DEV conforme solicitado anteriormente,
+        // o que ajuda na RAM pois não mantém a AST antiga em memória.
         cache: isProduction ? true : false,
         perf: false,
+        // Limita execuções paralelas de leitura de arquivo internas do Rollup
+        maxParallelFileOps: 20,
         plugins: [
-            // CRÍTICO: 'replace' deve vir PRIMEIRO para injetar NODE_ENV antes que
-            // libs como React decidam qual bundle importar.
             replace({
                 preventAssignment: true,
                 values: {
                     'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development')
                 }
             }),
-            // Precisa vir antes do nodeResolve
             tsconfigPathsPlugin(process.cwd()),
             nodeResolve({
                 extensions: ['.mjs', '.js', '.json', '.node', '.jsx', '.tsx', '.ts'],
@@ -331,20 +316,21 @@ function createRollupConfig(entryPoint, outdir, isProduction) {
             }),
             commonjs({
                 sourceMap: !isProduction,
-                requireReturnsDefault: 'auto'
+                requireReturnsDefault: 'auto',
+                // Ignora try-catch dinâmicos para economizar análise
+                ignoreTryCatch: true
             }),
             markdownPlugin(),
-            // Passamos isProduction para ativar a Extração Inteligente
+            // PostCSS Otimizado
             customPostCssPlugin(isProduction),
-            // Substitui forceBase64Plugin pelo Smart
+            // Assets Otimizados (menos Base64)
             smartAssetPlugin(isProduction),
             esbuild({
                 include: /\.[jt]sx?$/,
                 exclude: /node_modules/,
                 sourceMap: !isProduction,
                 minify: isProduction,
-                // Otimização: Remove comentários legais em produção
-                legalComments: isProduction ? 'none' : 'eof',
+                legalComments: 'none', // Remove comentários para limpar buffer
                 treeShaking: isProduction,
                 target: isProduction ? 'es2020' : 'esnext',
                 jsx: 'automatic',
@@ -357,6 +343,9 @@ function createRollupConfig(entryPoint, outdir, isProduction) {
                 return;
             if (warning.code === 'THIS_IS_UNDEFINED')
                 return;
+            // Ignora avisos circulares comuns que enchem o log/buffer
+            if (warning.code === 'CIRCULAR_DEPENDENCY' && warning.message.includes('node_modules'))
+                return;
             warn(warning);
         }
     };
@@ -371,39 +360,31 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
         const outputOptions = {
             dir: outdir,
             format: 'es',
-            // Padrão de nomes mantido, mas com estrutura para vários arquivos
             entryFileNames: isProduction ? 'main-[hash].js' : 'main.js',
             chunkFileNames: 'chunks/[name]-[hash].js',
             assetFileNames: 'assets/[name]-[hash][extname]',
             sourcemap: !isProduction,
-            // OTIMIZAÇÃO: Separação granular para melhor Cache e Load Time
+            // Compacta output para economizar memória de escrita
+            compact: isProduction,
             manualChunks(id) {
                 if (id.includes('node_modules')) {
-                    // Normaliza separadores para garantir funcionamento em Windows/Linux
                     const normalizedId = id.replace(/\\/g, '/');
-                    // React Core isolado
-                    // IMPORTANTE: Uso de Regex para garantir que pegamos APENAS os pacotes do core
-                    // e não pacotes que tenham 'react' no nome (ex: react-router, react-icons),
-                    // pois isso causa dependências circulares com o chunk 'vendor'.
                     if (/\/node_modules\/(react|react-dom|scheduler|prop-types|loose-envify|object-assign)\//.test(normalizedId)) {
                         return 'vendor-react';
                     }
-                    // UI Libs comuns (opcional, pode ajustar conforme necessidade)
                     if (id.includes('framer-motion') || id.includes('@radix-ui')) {
                         return 'vendor-ui';
                     }
-                    // Utils comuns
                     if (id.includes('lodash') || id.includes('date-fns') || id.includes('axios')) {
                         return 'vendor-utils';
                     }
-                    // Resto das dependências
                     return 'vendor';
                 }
             }
         };
         const bundle = await rollup(inputOptions);
         await bundle.write(outputOptions);
-        await bundle.close();
+        await bundle.close(); // Importante fechar para liberar memória
     }
     catch (error) {
         Console.error('An error occurred while building with chunks:', error);
@@ -421,9 +402,10 @@ async function build(entryPoint, outfile, isProduction = false) {
         const outputOptions = {
             file: outfile,
             format: 'iife',
-            name: 'HwebApp',
+            name: 'Vattsjs',
             sourcemap: !isProduction,
-            inlineDynamicImports: true
+            inlineDynamicImports: true,
+            compact: true // Ajuda na RAM
         };
         const bundle = await rollup(inputOptions);
         await bundle.write(outputOptions);
@@ -438,20 +420,22 @@ async function build(entryPoint, outfile, isProduction = false) {
  * Helper para lidar com notificações do Watcher
  */
 function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
-    // Controla o estado do build por "geração" para evitar END atrasado
-    // (ou múltiplos ciclos) emitirem sucesso após um erro.
     let currentBuildId = 0;
     let lastStartedBuildId = 0;
     const erroredBuildIds = new Set();
-    // DEBUG: stack trace rate-limited
-    let lastTraceAt = 0;
     watcher.on('event', event => {
         if (event.code === 'START') {
             currentBuildId += 1;
             lastStartedBuildId = currentBuildId;
+            // Dica pro V8 limpar lixo antes de começar um build pesado
+            if (global.gc) {
+                try {
+                    global.gc();
+                }
+                catch (e) { }
+            }
         }
         if (event.code === 'ERROR') {
-            // Marca erro para o build atualmente em andamento.
             erroredBuildIds.add(currentBuildId);
             const errDetails = {
                 message: event.error?.message || 'Unknown build error',
@@ -461,7 +445,6 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
                 loc: event.error?.loc,
                 buildId: currentBuildId
             };
-            // Notifica erro imediatamente
             if (hotReloadManager) {
                 hotReloadManager.onBuildComplete(false, errDetails);
             }
@@ -470,21 +453,18 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
             if (resolveFirstBuild)
                 resolveFirstBuild();
         }
-        if (event.code === 'BUNDLE_END')
+        if (event.code === 'BUNDLE_END') {
+            // CRÍTICO: Fechar o bundle libera a memória dos módulos
             event.result.close();
+        }
         if (event.code === 'END') {
             const endBuildId = currentBuildId;
             const hadError = erroredBuildIds.has(endBuildId);
-            // Só emite sucesso se:
-            //  1) esse END é do build mais recentemente iniciado (evita END atrasado)
-            //  2) esse build não teve ERROR
             if (endBuildId === lastStartedBuildId && !hadError) {
                 if (hotReloadManager) {
                     hotReloadManager.onBuildComplete(true, { buildId: endBuildId });
                 }
             }
-            // Limpa estados antigos pra não crescer sem limite.
-            // (qualquer build mais antigo que o último START não faz mais sentido manter)
             for (const id of erroredBuildIds) {
                 if (id < lastStartedBuildId)
                     erroredBuildIds.delete(id);
@@ -502,11 +482,9 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
 async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        // DEV MODE: isProduction = false
         const inputOptions = createRollupConfig(entryPoint, outdir, false);
         const outputOptions = {
             dir: outdir,
-            // Em DEV usamos ESM para suportar externals como react/react-dom sem output.globals
             format: 'es',
             entryFileNames: 'main.js',
             sourcemap: true
@@ -517,7 +495,9 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
             watch: {
                 exclude: 'node_modules/**',
                 clearScreen: false,
-                skipWrite: false
+                skipWrite: false,
+                // Atraso curto para evitar múltiplos rebuilds rápidos que comem CPU/RAM
+                buildDelay: 100
             }
         };
         const watcher = rollupWatch(watchOptions);
@@ -540,7 +520,6 @@ async function watch(entryPoint, outfile, hotReloadManager = null) {
         const inputOptions = createRollupConfig(entryPoint, outdir, false);
         const outputOptions = {
             file: outfile,
-            // Em DEV usamos ESM para suportar externals como react/react-dom sem output.globals
             format: 'es',
             sourcemap: true
         };
@@ -549,7 +528,8 @@ async function watch(entryPoint, outfile, hotReloadManager = null) {
             output: outputOptions,
             watch: {
                 exclude: 'node_modules/**',
-                clearScreen: false
+                clearScreen: false,
+                buildDelay: 100
             }
         };
         const watcher = rollupWatch(watchOptions);
@@ -569,14 +549,21 @@ async function cleanDirectoryExcept(dirPath, excludeFolder) {
             return;
         const excludes = Array.isArray(excludeFolder) ? excludeFolder : [excludeFolder];
         const items = await readdir(dirPath);
-        // Paraleliza a limpeza
-        await Promise.all(items.map(async (item) => {
+        // OTIMIZAÇÃO: Loop sequencial ao invés de Promise.all.
+        // Promise.all é mais rápido, mas cria dezenas/centenas de Promises simultâneas na RAM.
+        // O loop sequencial é mais gentil com o Garbage Collector.
+        for (const item of items) {
             if (excludes.includes(item))
-                return;
+                continue;
             const itemPath = path.join(dirPath, item);
-            const info = await stat(itemPath);
-            await rm(itemPath, { recursive: info.isDirectory(), force: true });
-        }));
+            try {
+                const info = await stat(itemPath);
+                await rm(itemPath, { recursive: info.isDirectory(), force: true });
+            }
+            catch (e) {
+                // Ignora erro se arquivo sumir durante o loop
+            }
+        }
     }
     catch (e) {
         Console.warn(`Warning cleaning directory: ${e.message}`);

package/dist/client/clientRouter.js

@@ -15,7 +15,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Sistema de roteamento do lado do cliente para hweb-sdk
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.router = void 0;
 class Router {

package/dist/client/entry.client.js

@@ -201,7 +201,7 @@ function App({ componentMap, routes, initialComponentPath, initialParams, layout
     // para garantir que o ErrorModal apareça em qualquer estado.
     let resolvedContent;
     if (!CurrentPageComponent || initialComponentPath === '__404__') {
-        const NotFoundComponent = window.__HWEB_NOT_FOUND__;
+        const NotFoundComponent = window.__VATTS_NOT_FOUND__;
         if (NotFoundComponent) {
             const NotFoundContent = (0, jsx_runtime_1.jsx)(NotFoundComponent, {});
             resolvedContent = layoutComponent
@@ -209,7 +209,7 @@ function App({ componentMap, routes, initialComponentPath, initialParams, layout
                 : NotFoundContent;
         }
         else {
-            const DefaultNotFound = window.__HWEB_DEFAULT_NOT_FOUND__;
+            const DefaultNotFound = window.__VATTS_DEFAULT_NOT_FOUND__;
             const NotFoundContent = (0, jsx_runtime_1.jsx)(DefaultNotFound, {});
             resolvedContent = layoutComponent
                 ? react_1.default.createElement(layoutComponent, { children: NotFoundContent })
@@ -261,11 +261,11 @@ function initializeClient() {
         // Cria o mapa de componentes dinamicamente a partir dos módulos carregados
         const componentMap = {};
         // Registra todos os componentes que foram importados
-        if (window.__HWEB_COMPONENTS__) {
-            Object.assign(componentMap, window.__HWEB_COMPONENTS__);
+        if (window.__VATTS_COMPONENTS__) {
+            Object.assign(componentMap, window.__VATTS_COMPONENTS__);
         }
         else {
-            console.warn('[Vatts] No components found in window.__HWEB_COMPONENTS__');
+            console.warn('[Vatts] No components found in window.__VATTS_COMPONENTS__');
         }
         const container = document.getElementById('root');
         if (!container) {
@@ -292,7 +292,7 @@ function initializeClient() {
         const root = (0, client_1.createRoot)(container);
         // Salva a referência globalmente
         window.__VATTS_ROOT__ = root;
-        root.render((0, jsx_runtime_1.jsx)(App, { componentMap: componentMap, routes: initialData.routes, initialComponentPath: initialData.initialComponentPath, initialParams: initialData.initialParams, layoutComponent: window.__HWEB_LAYOUT__ }));
+        root.render((0, jsx_runtime_1.jsx)(App, { componentMap: componentMap, routes: initialData.routes, initialComponentPath: initialData.initialComponentPath, initialParams: initialData.initialParams, layoutComponent: window.__VATTS_LAYOUT__ }));
     }
     catch (error) {
         console.error('[Watts] Critical Error rendering application:', error);
@@ -316,7 +316,7 @@ if (document.readyState === 'loading') {
 else {
     // ESM Hoisting Fix:
     // Como este arquivo é importado pelo arquivo gerado automaticamente, ele executa
-    // ANTES do corpo do arquivo gerado (onde window.__HWEB_COMPONENTS__ é definido).
+    // ANTES do corpo do arquivo gerado (onde window.__VATTS_COMPONENTS__ é definido).
     // Usamos setTimeout para garantir que a inicialização ocorra após as atribuições globais.
     setTimeout(initializeClient, 0);
 }

package/dist/env/env.d.ts

@@ -0,0 +1,5 @@
+export declare const loadEnv: (options: {
+    dir: string;
+    dev: boolean;
+    envFiles?: string[];
+}) => void;

package/dist/env/env.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnv = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const console_1 = __importDefault(require("../api/console"));
+function parse(src) {
+    const obj = {};
+    const lines = src.toString().split('\n');
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith('#') || trimmedLine === '') {
+            continue;
+        }
+        const match = trimmedLine.match(/^([^=]+)=(.*)$/);
+        if (match) {
+            const key = match[1].trim();
+            let value = match[2].trim();
+            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.substring(1, value.length - 1);
+            }
+            obj[key] = value;
+        }
+    }
+    return obj;
+}
+function applyEnv(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return;
+    try {
+        const fileContent = fs_1.default.readFileSync(filePath, 'utf-8');
+        const parsed = parse(fileContent);
+        for (const key in parsed) {
+            if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+                process.env[key] = parsed[key];
+            }
+        }
+    }
+    catch (e) {
+        console_1.default.error(`Error loading env file ${filePath}:`, e);
+    }
+}
+const loadEnv = (options) => {
+    const { dir, dev, envFiles = [] } = options;
+    const filesToLoad = [".env", ...envFiles].map((file) => path_1.default.join(dir, file));
+    filesToLoad.forEach(applyEnv);
+    if (dev) {
+        for (const file of filesToLoad) {
+            if (fs_1.default.existsSync(file)) {
+                let watchTimeout;
+                fs_1.default.watch(file, (eventType) => {
+                    if (eventType === 'change') {
+                        // Limpa o timeout anterior para evitar execuções múltiplas
+                        clearTimeout(watchTimeout);
+                        // Define um novo timeout de 100ms
+                        watchTimeout = setTimeout(() => {
+                            console_1.default.info(`Reloading environment variables from ${path_1.default.basename(file)}.`);
+                            applyEnv(file);
+                        }, 100);
+                    }
+                });
+            }
+        }
+    }
+};
+exports.loadEnv = loadEnv;

package/dist/helpers.js

@@ -132,6 +132,7 @@ async function loadVattsConfig(projectDir, phase) {
         individualRequestTimeout: 30000,
         maxUrlLength: 2048,
         accessLogging: true,
+        envFiles: [],
     };
     try {
         // Tenta primeiro .ts, depois .js
@@ -315,13 +316,15 @@ const parseBody = (req) => {
 /**
  * Inicializa servidor nativo do Vatts.js usando HTTP ou HTTPS
  */
-async function initNativeServer(hwebApp, options, port, hostname) {
+async function initNativeServer(vattsApp, options, port, hostname) {
     const time = Date.now();
-    await hwebApp.prepare();
     const projectDir = options.dir || process.cwd();
     const phase = options.dev ? 'development' : 'production';
     const vattsConfig = await loadVattsConfig(projectDir, phase);
-    const handler = hwebApp.getRequestHandler();
+    // Passa envFiles da config para as opções do vatts
+    options.envFiles = vattsConfig.envFiles;
+    await vattsApp.prepare();
+    const handler = vattsApp.getRequestHandler();
     const msg = console_1.default.dynamicLine(`${console_1.Colors.Bright}Starting Vatts.js on port ${options.port}${console_1.Colors.Reset}`);
     // --- LÓGICA DO LISTENER (REUTILIZÁVEL) ---
     // Extraímos a lógica principal para uma variável
@@ -461,7 +464,7 @@ async function initNativeServer(hwebApp, options, port, hostname) {
             ca: options.ssl.ca ? fs_1.default.readFileSync(options.ssl.ca) : undefined
         };
         // 1. Cria o servidor HTTPS principal
-        server = https_1.default.createServer(sslOptions, requestListener); // (any para contornar HWebIncomingMessage)
+        server = https_1.default.createServer(sslOptions, requestListener);
         // 2. Cria o servidor de REDIRECIONAMENTO (HTTP -> HTTPS)
         const httpRedirectPort = options.ssl.redirectPort;
         http_1.default.createServer((req, res) => {
@@ -490,7 +493,7 @@ async function initNativeServer(hwebApp, options, port, hostname) {
     else {
         // --- MODO HTTP (Original) ---
         // Cria o servidor HTTP nativo
-        server = http_1.default.createServer(requestListener); // (any para contornar HWebIncomingMessage)
+        server = http_1.default.createServer(requestListener);
     }
     // Configurações de segurança do servidor (usa configuração personalizada)
     server.setTimeout(vattsConfig.serverTimeout || 35000); // Timeout geral do servidor
@@ -502,26 +505,26 @@ async function initNativeServer(hwebApp, options, port, hostname) {
         msg.end(`${console_1.Colors.Bright}Ready on port ${console_1.Colors.BgGreen} ${options.port} ${console_1.Colors.Reset}${console_1.Colors.Bright} in ${Date.now() - time}ms${console_1.Colors.Reset}\n`);
     });
     // Configura WebSocket para hot reload (Comum a ambos)
-    hwebApp.setupWebSocket(server);
-    hwebApp.executeInstrumentation();
+    vattsApp.setupWebSocket(server);
+    vattsApp.executeInstrumentation();
     return server;
 }
 // --- Função Principal ---
 function app(options = {}) {
     const framework = options.framework || 'native';
     index_1.FrameworkAdapterFactory.setFramework(framework);
-    // Tipando a app principal do hweb
-    const hwebApp = (0, index_1.default)(options);
+    // Tipando a app principal do vatts
+    const vattsApp = (0, index_1.default)(options);
     return {
-        ...hwebApp,
+        ...vattsApp,
         /**
          * Integra com uma aplicação de qualquer framework (Express, Fastify, etc)
          * O 'serverApp: any' é mantido para flexibilidade, já que pode ser de tipos diferentes.
          */
         integrate: async (serverApp) => {
-            await hwebApp.prepare();
-            const handler = hwebApp.getRequestHandler();
-            // O framework é setado nas opções do hweb, que deve
+            await vattsApp.prepare();
+            const handler = vattsApp.getRequestHandler();
+            // O framework é setado nas opções do vatts, que deve
             // retornar o handler correto em getRequestHandler()
             // A lógica de integração original parece correta.
             if (framework === 'express') {
@@ -536,7 +539,7 @@ function app(options = {}) {
                 serverApp.use(express.json());
                 serverApp.use(express.urlencoded({ extended: true }));
                 serverApp.use(handler);
-                hwebApp.setupWebSocket(serverApp);
+                vattsApp.setupWebSocket(serverApp);
             }
             else if (framework === 'fastify') {
                 try {
@@ -554,14 +557,14 @@ function app(options = {}) {
                 await serverApp.register(async (fastify) => {
                     fastify.all('*', handler);
                 });
-                hwebApp.setupWebSocket(serverApp);
+                vattsApp.setupWebSocket(serverApp);
             }
             else {
                 // Generic integration (assume Express-like)
                 serverApp.use(handler);
-                hwebApp.setupWebSocket(serverApp);
+                vattsApp.setupWebSocket(serverApp);
             }
-            hwebApp.executeInstrumentation();
+            vattsApp.executeInstrumentation();
             return serverApp;
         },
         /**
@@ -602,7 +605,7 @@ ${console_1.Colors.Bright + console_1.Colors.FgRed}     \\/  /~~\\  |   |  .__/
             if (framework !== 'native') {
                 console_1.default.warn(`The "${framework}" framework was selected, but the init() method only works with the "native" framework. Starting native server...`);
             }
-            return await initNativeServer(hwebApp, options, actualPort, actualHostname);
+            return await initNativeServer(vattsApp, options, actualPort, actualHostname);
         }
     };
 }

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { GenericRequest, GenericResponse, CookieOptions } from './types/fra
 export { app } from './helpers';
 export type { WebSocketContext, WebSocketHandler } from './types';
 export type { VattsConfig, VattsConfigFunction } from './types';
-export default function hweb(options: VattsOptions): {
+export default function vatts(options: VattsOptions): {
     prepare: () => Promise<void>;
     executeInstrumentation: () => void;
     getRequestHandler: () => RequestHandler;

package/dist/index.js

@@ -53,7 +53,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = exports.FrameworkAdapterFactory = exports.FastifyAdapter = exports.ExpressAdapter = exports.VattsResponse = exports.VattsRequest = void 0;
-exports.default = hweb;
+exports.default = vatts;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const express_1 = require("./adapters/express");
@@ -66,6 +66,7 @@ Object.defineProperty(exports, "VattsResponse", { enumerable: true, get: functio
 const hotReload_1 = require("./hotReload");
 const factory_1 = require("./adapters/factory");
 const console_1 = __importStar(require("./api/console"));
+const env_1 = require("./env/env");
 // RPC
 const server_1 = require("./rpc/server");
 const types_1 = require("./rpc/types");
@@ -161,12 +162,12 @@ function createEntryFile(projectDir, routes) {
             .join('\n');
         // Registra o layout se existir
         const layoutRegistration = layout
-            ? `window.__HWEB_LAYOUT__ = LayoutComponent.default || LayoutComponent;`
-            : `window.__HWEB_LAYOUT__ = null;`;
+            ? `window.__VATTS_LAYOUT__ = LayoutComponent.default || LayoutComponent;`
+            : `window.__VATTS_LAYOUT__ = null;`;
         // Registra o notFound se existir
         const notFoundRegistration = notFound
-            ? `window.__HWEB_NOT_FOUND__ = NotFoundComponent.default || NotFoundComponent;`
-            : `window.__HWEB_NOT_FOUND__ = null;`;
+            ? `window.__VATTS_NOT_FOUND__ = NotFoundComponent.default || NotFoundComponent;`
+            : `window.__VATTS_NOT_FOUND__ = null;`;
         // Caminho correto para o entry.client
         // IMPORTANT: quando o pacote é instalado via npm, bundlers (Rollup/Vite/etc.) não transpilam TSX em node_modules.
         // Por isso, aqui a gente sempre aponta para os artefatos compilados em dist/.
@@ -176,14 +177,14 @@ function createEntryFile(projectDir, routes) {
         // Import do DefaultNotFound do SDK (compilado)
         const defaultNotFoundPath = path_1.default.join(sdkDir, 'dist', 'client', 'DefaultNotFound.js');
         const relativeDefaultNotFoundPath = path_1.default.relative(tempDir, defaultNotFoundPath).replace(/\\/g, '/');
-        const entryContent = `// Arquivo gerado automaticamente pelo hweb
+        const entryContent = `// Arquivo gerado automaticamente pelo vatts
 ${imports}
 ${layoutImport}
 ${notFoundImport}
 import DefaultNotFound from '${relativeDefaultNotFoundPath}';
 
 // Registra os componentes para o cliente
-window.__HWEB_COMPONENTS__ = {
+window.__VATTS_COMPONENTS__ = {
 ${componentRegistration}
 };
 
@@ -193,8 +194,8 @@ ${layoutRegistration}
 // Registra o notFound se existir
 ${notFoundRegistration}
 
-// Registra o DefaultNotFound do hweb
-window.__HWEB_DEFAULT_NOT_FOUND__ = DefaultNotFound;
+
+window.__VATTS_DEFAULT_NOT_FOUND__ = DefaultNotFound;
 
 // Importa e executa o entry.client.tsx
 import '${relativeEntryPath}';
@@ -212,8 +213,9 @@ import '${relativeEntryPath}';
         throw e;
     }
 }
-function hweb(options) {
-    const { dev = true, dir = process.cwd(), port = 3000 } = options;
+function vatts(options) {
+    const { dev = true, dir = process.cwd(), port = 3000, envFiles } = options;
+    (0, env_1.loadEnv)({ dir, dev, envFiles });
     // @ts-ignore
     process.vatts = options;
     const userWebDir = path_1.default.join(dir, 'src', 'web');

package/dist/renderer.js

@@ -175,7 +175,7 @@ async function render({ req, route, params, allRoutes }) {
 <html lang="${htmlLang}">
 <head>
 ${metaTags}
-<title>${metadata.title || 'App hweb'}</title>
+<title>${metadata.title || 'Vatts.js'}</title>
 </head>
 <body>
 <div id="root"></div>

package/dist/types.d.ts

@@ -26,6 +26,7 @@ export interface VattsOptions {
         cert: string;
         ca?: string;
     };
+    envFiles?: string[];
 }
 /**
  * Interface para as configurações avançadas do servidor Vatts.js.
@@ -137,6 +138,10 @@ export interface VattsConfig {
      * Exemplo: { 'X-Custom-Header': 'value', 'X-Powered-By': 'Vatts.js' }
      */
     customHeaders?: Record<string, string>;
+    /**
+     * Arquivos .env adicionais para carregar. O .env padrão é sempre carregado.
+     */
+    envFiles?: string[];
 }
 /**
  * Tipo da função de configuração que pode ser exportada no vatts.config.js
@@ -192,12 +197,10 @@ export type RequestHandler = (req: any, res: any) => Promise<void>;
 /**
  * Define o formato de uma função que manipula uma rota da API.
  */
-export type BackendHandler = (request: VattsRequest, // HWebRequest será importado onde necessário
-params: {
+export type BackendHandler = (request: VattsRequest, params: {
     [key: string]: string;
 }) => Promise<VattsResponse> | VattsResponse;
-export type VattsMiddleware = (request: VattsRequest, // HWebRequest será importado onde necessário
-params: {
+export type VattsMiddleware = (request: VattsRequest, params: {
     [key: string]: string;
 }, next: () => Promise<VattsResponse>) => Promise<VattsResponse> | VattsResponse;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vatts",
-  "version": "1.0.2-alpha.1",
+  "version": "1.0.2-alpha.3",
   "description": "Vatts.js is a high-level framework for building web applications with ease and speed. It provides a robust set of tools and features to streamline development and enhance productivity.",
   "types": "dist/index.d.ts",
   "author": "itsmuzin",