vatts 1.3.1-test.3 → 1.4.1-test.1

package/dist/api/http3.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Interface para as opções do servidor Proxy HTTP/3.
+ */
+export interface ProxyOptions {
+    /** Porta HTTP para redirecionamento (ex: ":80") */
+    httpPort: string;
+    /** Porta HTTPS/HTTP3 (ex: ":443") */
+    httpsPort: string;
+    /** URL do servidor backend (ex: "http://localhost:3000") */
+    backendUrl: string;
+    /** Caminho para o arquivo de certificado SSL (.pem) */
+    certPath: string;
+    /** Caminho para o arquivo de chave privada SSL (.pem) */
+    keyPath: string;
+    /** (Opcional) Sobrescreve o caminho da biblioteca manualmente */
+    customLibPath?: string;
+}
+export declare class NativeProxy {
+    private static instance;
+    /**
+     * Detecta a plataforma e arquitetura para montar o nome do arquivo.
+     * Padrão esperado: vatts-proxy-{os}-{arch}.node
+     * Ex: vatts-proxy-win-x64.node
+     */
+    static getLibPath(): string;
+    /**
+     * Carrega a biblioteca nativa usando Koffi.
+     */
+    private static loadLibrary;
+    /**
+     * Inicia o servidor Proxy.
+     * Nota: A execução no Go é assíncrona (non-blocking), então esta função retorna
+     * imediatamente após iniciar as threads do servidor, a menos que haja um erro inicial.
+     */
+    static start(options: ProxyOptions): void;
+}
+/**
+ * API Pública
+ */
+export declare const startProxy: (options: ProxyOptions) => void;
+export default startProxy;

package/dist/api/http3.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startProxy = exports.NativeProxy = void 0;
+const koffi_1 = __importDefault(require("koffi"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+class NativeProxy {
+    static instance = null;
+    /**
+     * Detecta a plataforma e arquitetura para montar o nome do arquivo.
+     * Padrão esperado: vatts-proxy-{os}-{arch}.node
+     * Ex: vatts-proxy-win-x64.node
+     */
+    static getLibPath() {
+        const platform = os_1.default.platform();
+        const arch = os_1.default.arch();
+        let osName = '';
+        let ext = '.node'; // Mantendo sua convenção de extensão
+        // Mapeamento de SO
+        switch (platform) {
+            case 'win32':
+                osName = 'win';
+                break;
+            case 'linux':
+                osName = 'linux';
+                break;
+            case 'darwin':
+                osName = 'darwin';
+                break;
+            default:
+                throw new Error(`Sistema operacional não suportado: ${platform}`);
+        }
+        // Mapeamento de Arquitetura
+        let archName = '';
+        switch (arch) {
+            case 'x64':
+                archName = 'x64';
+                break;
+            case 'arm64':
+                archName = 'arm64';
+                break;
+            default:
+                throw new Error(`Arquitetura não suportada: ${arch}`);
+        }
+        const filename = `core-${osName}-${archName}${ext}`;
+        // Ajuste o caminho relativo conforme a estrutura do seu projeto
+        // Assumindo que estará na pasta '../proxy' relativo a este arquivo
+        return path_1.default.resolve(__dirname, '..', 'core-go', filename);
+    }
+    /**
+     * Carrega a biblioteca nativa usando Koffi.
+     */
+    static loadLibrary(customPath) {
+        if (this.instance)
+            return this.instance;
+        const libPath = customPath || this.getLibPath();
+        if (!fs_1.default.existsSync(libPath)) {
+            throw new Error(`Biblioteca nativa não encontrada: ${libPath}.\n`);
+        }
+        try {
+            const lib = koffi_1.default.load(libPath);
+            // Mapeia a função Go: StartServer
+            // Argumentos: 5 strings
+            // Retorno: string (erro) ou null (sucesso)
+            this.instance = lib.func('StartServer', 'str', ['str', 'str', 'str', 'str', 'str']);
+            return this.instance;
+        }
+        catch (error) {
+            throw new Error(`Falha ao carregar a biblioteca nativa de proxy em ${libPath}: ${error}`);
+        }
+    }
+    /**
+     * Inicia o servidor Proxy.
+     * Nota: A execução no Go é assíncrona (non-blocking), então esta função retorna
+     * imediatamente após iniciar as threads do servidor, a menos que haja um erro inicial.
+     */
+    static start(options) {
+        const { httpPort, httpsPort, backendUrl, certPath, keyPath, customLibPath } = options;
+        const startServer = this.loadLibrary(customLibPath);
+        // Resolve caminhos absolutos para evitar erros no Go
+        const absCert = path_1.default.resolve(certPath);
+        const absKey = path_1.default.resolve(keyPath);
+        // Validação básica de existência dos arquivos de certificado antes de chamar o Go
+        if (!fs_1.default.existsSync(absCert)) {
+            throw new Error(`Arquivo de certificado não encontrado: ${absCert}`);
+        }
+        if (!fs_1.default.existsSync(absKey)) {
+            throw new Error(`Arquivo de chave não encontrado: ${absKey}`);
+        }
+        // Chama a função nativa
+        const errorMsg = startServer(httpPort, httpsPort, backendUrl, absCert, absKey);
+        if (errorMsg) {
+            throw new Error(`[Vatts Proxy Error] ${errorMsg}`);
+        }
+    }
+}
+exports.NativeProxy = NativeProxy;
+/**
+ * API Pública
+ */
+const startProxy = (options) => {
+    return NativeProxy.start(options);
+};
+exports.startProxy = startProxy;
+// Export padrão
+exports.default = exports.startProxy;

package/dist/api/optimizer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Interface para as opções do otimizador.
+ */
+export interface OptimizerOptions {
+    /** Diretório onde estão os arquivos a serem otimizados (ex: .vatts/exported) */
+    targetDir: string;
+    /** (Opcional) Diretório de saída. Padrão: 'optimized' dentro do target */
+    outputDir?: string;
+    /** (Opcional) Lista de arquivos ou pastas a serem ignorados */
+    ignoredPatterns?: string[];
+    /** (Opcional) Sobrescreve o caminho da biblioteca manualmemte */
+    customLibPath?: string;
+}
+export declare class NativeOptimizer {
+    private static instance;
+    /**
+     * Detecta a plataforma e arquitetura para montar o nome do arquivo.
+     * Padrão esperado: optimizer-{os}-{arch}.{ext}
+     * Ex: optimizer-win-64.dll, optimizer-linux-arm64.so
+     */
+    static getLibPath(): string;
+    /**
+     * Carrega a biblioteca nativa usando Koffi.
+     */
+    private static loadLibrary;
+    /**
+     * Executa a otimização.
+     */
+    static run(options: OptimizerOptions): void;
+}
+/**
+ * API Pública
+ */
+export declare const runOptimizer: (options: OptimizerOptions) => void;
+export default runOptimizer;

package/dist/api/optimizer.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOptimizer = exports.NativeOptimizer = void 0;
+const koffi_1 = __importDefault(require("koffi"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+class NativeOptimizer {
+    static instance = null;
+    /**
+     * Detecta a plataforma e arquitetura para montar o nome do arquivo.
+     * Padrão esperado: optimizer-{os}-{arch}.{ext}
+     * Ex: optimizer-win-64.dll, optimizer-linux-arm64.so
+     */
+    static getLibPath() {
+        const platform = os_1.default.platform(); // 'win32', 'linux', 'darwin'
+        const arch = os_1.default.arch(); // 'x64', 'arm64'
+        let osName = '';
+        let ext = '.node';
+        // Mapeamento de SO
+        switch (platform) {
+            case 'win32':
+                osName = 'win';
+                break;
+            case 'linux':
+                osName = 'linux';
+                break;
+            case 'darwin':
+                osName = 'darwin'; // ou 'darwin', ajuste conforme seu build
+                break;
+            default:
+                throw new Error(`Sistema operacional não suportado: ${platform}`);
+        }
+        // Mapeamento de Arquitetura (user pediu '64' para x64)
+        let archName = '';
+        switch (arch) {
+            case 'x64':
+                archName = 'x64';
+                break;
+            case 'arm64':
+                archName = 'arm64';
+                break;
+            default:
+                throw new Error(`Arquitetura não suportada: ${arch}`);
+        }
+        const filename = `core-${osName}-${archName}${ext}`;
+        // Caminho relativo: sobe um nível (fora do dist/src) e entra em builds
+        // Ajuste o '..' conforme a estrutura final da sua pasta de compilação
+        return path_1.default.resolve(__dirname, '..', 'core-go', filename);
+    }
+    /**
+     * Carrega a biblioteca nativa usando Koffi.
+     */
+    static loadLibrary(customPath) {
+        if (this.instance)
+            return this.instance;
+        const libPath = customPath || this.getLibPath();
+        if (!fs_1.default.existsSync(libPath)) {
+            throw new Error(`Biblioteca nativa não encontrada: ${libPath}.\n`);
+        }
+        try {
+            const lib = koffi_1.default.load(libPath);
+            // Mapeia a função Go: func Optimize(...) *C.char
+            // Em Koffi, 'str' como retorno significa char* (string C)
+            // Se o Go retornar nil, o Koffi converte para null no JS
+            this.instance = lib.func('Optimize', 'str', ['str', 'str', 'str']);
+            return this.instance;
+        }
+        catch (error) {
+            throw new Error(`Falha ao carregar a biblioteca nativa em ${libPath}: ${error}`);
+        }
+    }
+    /**
+     * Executa a otimização.
+     */
+    static run(options) {
+        const { targetDir, outputDir = '', ignoredPatterns = [], customLibPath } = options;
+        const optimize = this.loadLibrary(customLibPath);
+        const absTarget = path_1.default.resolve(targetDir);
+        const absOutput = outputDir ? path_1.default.resolve(outputDir) : '';
+        const ignoredStr = ignoredPatterns.join(',');
+        // Validação básica
+        if (!fs_1.default.existsSync(absTarget)) {
+            return;
+        }
+        const errorMsg = optimize(absTarget, absOutput, ignoredStr);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+    }
+}
+exports.NativeOptimizer = NativeOptimizer;
+/**
+ * API Pública
+ */
+const runOptimizer = (options) => {
+    return NativeOptimizer.run(options);
+};
+exports.runOptimizer = runOptimizer;
+// Export padrão também para facilitar imports
+exports.default = exports.runOptimizer;

package/dist/bin/vatts.js

@@ -94,6 +94,7 @@ program
     .option('--no-html', 'Do not generate index.html (assets only)')
     .option('--output-h-data <file>', 'Write the data-h value into this file')
     .action(async (options) => {
+    process.env.NODE_ENV = 'production';
     const projectDir = process.cwd();
     const outputInput = (typeof options.output === 'string' && options.output.trim()) || 'exported';
     const exportDirResolved = path.resolve(projectDir, outputInput);

package/dist/builder.js

@@ -1,4 +1,12 @@
 "use strict";
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 /*
  * This file is part of the Vatts.js Project.
  * Copyright (c) 2026 mfraz
@@ -15,19 +23,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 const { rollup, watch: rollupWatch } = require('rollup');
 const path = require('path');
 const Console = require("./api/console").default;
 const fs = require('fs');
-const { readdir, stat, rm } = require("node:fs/promises");
+const crypto = require('crypto');
+const { readdir, stat, rm, rename } = require("node:fs/promises");
 const { loadTsConfigPaths, resolveTsConfigAlias } = require('./tsconfigPaths');
 // --- Optimization Plugins ---
 let terser, replace;
@@ -137,12 +138,9 @@ const customPostCssPlugin = (isProduction, isWatch = false) => {
     };
     return {
         name: 'custom-postcss-plugin',
-        // O load hook anterior estava causando conflitos com o watch interno do Rollup.
-        // Removemos ele e usamos addWatchFile no transform.
         async transform(code, id) {
             if (!id.endsWith('.css'))
                 return null;
-            // Garante que o Rollup vigie este arquivo explicitamente
             if (isWatch) {
                 this.addWatchFile(id);
             }
@@ -157,13 +155,13 @@ const customPostCssPlugin = (isProduction, isWatch = false) => {
                     Console.warn(`PostCSS process error:`, e.message);
                 }
             }
-            const cleanName = path.basename(id).split('?')[0];
+            // --- FIX: Evitar colisão de nomes usando Hash do ID ---
+            const hash = crypto.createHash('md5').update(id).digest('hex').slice(0, 8);
+            const baseName = path.basename(id).split('?')[0];
+            const uniqueName = `${hash}-${baseName}`;
             // Sanitiza o nome para usar como ID no DOM
-            const safeId = cleanName.replace(/[^a-zA-Z0-9-_]/g, '_');
-            const referenceId = this.emitFile({ type: 'asset', name: cleanName, source: processedCss });
-            // Lógica melhorada para injetar o CSS:
-            // 1. Usa um ID único para evitar tags <link> duplicadas.
-            // 2. Adiciona um timestamp (?t=...) no href se estiver em dev para quebrar o cache do navegador.
+            const safeId = uniqueName.replace(/[^a-zA-Z0-9-_]/g, '_');
+            const referenceId = this.emitFile({ type: 'asset', name: uniqueName, source: processedCss });
             return {
                 code: `
                 const cssUrl = String(import.meta.ROLLUP_FILE_URL_${referenceId});
@@ -178,7 +176,6 @@ const customPostCssPlugin = (isProduction, isWatch = false) => {
                         document.head.appendChild(link);
                     }
                     
-                    // Em dev, força o reload do CSS adicionando timestamp
                     const timestamp = ${isWatch ? 'Date.now()' : 'null'};
                     link.href = timestamp ? (cssUrl + '?t=' + timestamp) : cssUrl;
                 }
@@ -218,6 +215,10 @@ const smartAssetPlugin = (isProduction) => {
             }
             let buffer = await fs.promises.readFile(cleanId);
             const size = buffer.length;
+            // --- FIX: Evitar colisão de nomes em assets estáticos ---
+            const hash = crypto.createHash('md5').update(cleanId).digest('hex').slice(0, 8);
+            const baseName = path.basename(cleanId);
+            const uniqueName = `${hash}-${baseName}`;
             if (type === 'svg') {
                 if (size < INLINE_LIMIT) {
                     const content = buffer.toString('utf8');
@@ -228,7 +229,7 @@ const smartAssetPlugin = (isProduction) => {
                     `;
                 }
                 else {
-                    const referenceId = this.emitFile({ type: 'asset', name: path.basename(cleanId), source: buffer });
+                    const referenceId = this.emitFile({ type: 'asset', name: uniqueName, source: buffer });
                     const content = buffer.toString('utf8');
                     return `
                         export default String(import.meta.ROLLUP_FILE_URL_${referenceId});
@@ -241,7 +242,7 @@ const smartAssetPlugin = (isProduction) => {
                 return `export default "data:${type};base64,${base64}";`;
             }
             else {
-                const referenceId = this.emitFile({ type: 'asset', name: path.basename(cleanId), source: buffer });
+                const referenceId = this.emitFile({ type: 'asset', name: uniqueName, source: buffer });
                 return `export default String(import.meta.ROLLUP_FILE_URL_${referenceId});`;
             }
         }
@@ -379,12 +380,10 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
             manualChunks(id) {
                 if (id.includes('node_modules')) {
                     const normalizedId = id.replace(/\\/g, '/');
-                    // --- VUE SPLITTING AVANÇADO ---
                     if (/\/node_modules\/vue-router\//.test(normalizedId))
                         return 'vendor-vue-router';
                     if (/\/node_modules\/(pinia|vuex)\//.test(normalizedId))
                         return 'vendor-vue-store';
-                    // Separa os modulos internos do Vue para evitar um chunk gigante
                     if (/\/node_modules\/(vue|@vue)\//.test(normalizedId)) {
                         if (normalizedId.includes('/runtime-core'))
                             return 'vendor-vue-runtime-core';
@@ -398,8 +397,6 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
                             return 'vendor-vue-compiler';
                         return 'vendor-vue-core';
                     }
-                    // --- REACT SPLITTING AVANÇADO ---
-                    // Separa DOM de Core e Scheduler
                     if (/\/node_modules\/react-dom\//.test(normalizedId))
                         return 'vendor-react-dom';
                     if (/\/node_modules\/scheduler\//.test(normalizedId))
@@ -408,7 +405,6 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
                         return 'vendor-react-router';
                     if (/\/node_modules\/react\//.test(normalizedId))
                         return 'vendor-react-core';
-                    // --- UI LIBS (Granular) ---
                     if (id.includes('framer-motion'))
                         return 'vendor-framer';
                     if (id.includes('@radix-ui'))
@@ -417,15 +413,12 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
                         return 'vendor-headless';
                     if (id.includes('@heroicons'))
                         return 'vendor-icons';
-                    // --- UTILS ---
                     if (id.includes('lodash'))
                         return 'vendor-lodash';
                     if (id.includes('date-fns') || id.includes('moment'))
                         return 'vendor-date';
                     if (id.includes('axios'))
                         return 'vendor-axios';
-                    // Resto cai em vendor-libs genérico para não criar 1 arquivo por pacote,
-                    // mas já tiramos o peso pesado acima.
                     return 'vendor-libs';
                 }
             }
@@ -433,6 +426,51 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
         const bundle = await rollup(inputOptions);
         await bundle.write(outputOptions);
         await bundle.close();
+        // --- Native Optimization Integration ---
+        if (isProduction) {
+            try {
+                // Dynamically require to avoid issues if file doesn't exist in dev/non-opt environments
+                // Assuming ./api/optimizer matches the transpiled location of src/optimizer.ts
+                const { runOptimizer } = require('./api/optimizer');
+                const optimizedDir = path.join(outdir, 'optimized');
+                // 1. Run Optimizer
+                runOptimizer({
+                    targetDir: outdir,
+                    outputDir: optimizedDir,
+                    // Ignore already optimized assets or node_modules if present
+                    ignoredPatterns: ['assets']
+                });
+                // 2. Cleanup: Remove original main*.js and chunks folder from root
+                const rootFiles = await readdir(outdir);
+                for (const file of rootFiles) {
+                    // Match main.js, main.hash.js, etc and the chunks directory
+                    if ((file.startsWith('main') && file.endsWith('.js')) || file === 'chunks') {
+                        await rm(path.join(outdir, file), { recursive: true, force: true });
+                    }
+                }
+                // 3. Move optimized files back to root
+                if (fs.existsSync(optimizedDir)) {
+                    const optFiles = await readdir(optimizedDir);
+                    for (const file of optFiles) {
+                        const srcPath = path.join(optimizedDir, file);
+                        const destPath = path.join(outdir, file);
+                        // Force remove destination if it exists (e.g. if assets folder exists and we are moving optimized/assets)
+                        // This prevents EEXIST errors on rename
+                        await rm(destPath, { recursive: true, force: true });
+                        await rename(srcPath, destPath);
+                    }
+                    // Remove the now empty optimized directory
+                    await rm(optimizedDir, { recursive: true, force: true });
+                }
+                Console.log("✅ Build successfully optimized with native optimizer.");
+            }
+            catch (err) {
+                Console.error('Native optimization failed:', err);
+                // Not exiting process here to allow build to "succeed" even if optimization fails,
+                // though files might be in a weird state.
+                // If critical, uncomment: process.exit(1);
+            }
+        }
     }
     catch (error) {
         Console.error('An error occurred while building with chunks:', error);
@@ -541,7 +579,6 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
             dir: outdir,
             format: 'es',
             entryFileNames: 'main.js',
-            // CHANGE: Remove hash in watch mode to prevent file accumulation in assets folder
             assetFileNames: 'assets/[name][extname]',
             sourcemap: true,
             intro: processPolyfill
@@ -573,7 +610,6 @@ async function watch(entryPoint, outfile, hotReloadManager = null) {
         const outputOptions = {
             file: outfile,
             format: 'es',
-            // CHANGE: Remove hash in watch mode to prevent file accumulation
             assetFileNames: 'assets/[name][extname]',
             sourcemap: true,
             intro: processPolyfill

package/dist/helpers.d.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import http, { Server } from 'http';
 import type { VattsOptions, VattsConfig } from './types';
-import http2 from 'http2';
 /**
  * Carrega o arquivo de configuração vatts.config.ts ou vatts.config.js do projeto
  * @param projectDir Diretório raiz do projeto
@@ -20,7 +19,7 @@ export declare function app(options?: VattsOptions): {
     /**
      * Inicia um servidor Vatts.js fechado (o usuário não tem acesso ao framework)
      */
-    init: () => Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http2.Http2SecureServer<typeof http.IncomingMessage, typeof http.ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>>;
+    init: () => Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
     prepare: () => Promise<void>;
     getRequestHandler: () => (req: any, res: any, next?: any) => Promise<void> | void;
     setupWebSocket: (server: Server | any) => void;

package/dist/helpers.js

@@ -65,8 +65,8 @@ const path_1 = __importDefault(require("path"));
 // Helpers para integração com diferentes frameworks
 const index_js_1 = __importStar(require("./index.js")); // Importando o tipo
 const console_1 = __importStar(require("./api/console"));
-const http2_1 = __importDefault(require("http2")); // <-- ADICIONADO: Import do HTTP/2
 const fs_1 = __importDefault(require("fs"));
+const http3_1 = __importDefault(require("./api/http3"));
 // Registra loaders customizados para importar arquivos não-JS
 const { registerLoaders } = require('./loaders');
 registerLoaders({ projectDir: process.cwd() });
@@ -325,7 +325,7 @@ function setConfig(newConfig) {
 /**
  * Inicializa servidor nativo do Vatts.js usando HTTP ou HTTPS
  */
-async function initNativeServer(vattsApp, options, port, hostname) {
+async function initNativeServer(vattsApp, options, hostname) {
     const time = Date.now();
     const projectDir = options.dir || process.cwd();
     const phase = options.dev ? 'development' : 'production';
@@ -425,7 +425,7 @@ async function initNativeServer(vattsApp, options, port, hostname) {
             // Parse do body com proteções
             req.body = await parseBody(req); // Assumindo que parseBody existe
             // Adiciona host se não existir (necessário para `new URL`)
-            req.headers.host = req.headers.host || `localhost:${port}`;
+            req.headers.host = req.headers.host || `localhost:${exports.config?.port}`;
             await handler(req, res);
         }
         catch (error) {
@@ -465,51 +465,12 @@ async function initNativeServer(vattsApp, options, port, hostname) {
         }
     };
     // --- FIM DO LISTENER ---
-    let server; // <-- ADICIONADO: Suporte a Http2SecureServer
-    const isSSL = exports.config.ssl && exports.config.ssl.key && exports.config.ssl.cert;
-    if (isSSL && exports.config.ssl) {
-        const sslOptions = {
-            key: fs_1.default.readFileSync(exports.config.ssl.key, 'utf8'),
-            cert: fs_1.default.readFileSync(exports.config.ssl.cert, 'utf8'),
-            ca: exports.config.ssl.ca ? fs_1.default.readFileSync(exports.config.ssl.ca, 'utf8') : undefined,
-            allowHTTP1: true // <-- IMPORTANTE: Garante compatibilidade com clientes HTTP/1.1
-        };
-        // 1. Cria o servidor HTTPS com HTTP/2
-        // Substituído https.createServer por http2.createSecureServer
-        server = http2_1.default.createSecureServer(sslOptions, requestListener);
-        // 2. Cria o servidor de REDIRECIONAMENTO (HTTP -> HTTPS)
-        const httpRedirectPort = exports.config.ssl.redirectPort;
-        http_1.default.createServer((req, res) => {
-            // Evita host header injection/open redirect: prefere hostname configurado
-            const rawHost = String(req.headers['host'] || '').trim();
-            const configuredHost = (options.hostname || hostname || '').trim();
-            let hostToUse = configuredHost;
-            // Se não tiver hostname configurado, tenta usar Host do request com validação básica
-            if (!hostToUse) {
-                const hostWithoutPort = rawHost.split(':')[0];
-                // allowlist: hostname simples (sem espaços, sem barras), e sem caracteres perigosos
-                const isValidHost = /^[a-zA-Z0-9.-]+$/.test(hostWithoutPort) && !hostWithoutPort.includes('..');
-                hostToUse = isValidHost ? hostWithoutPort : 'localhost';
-            }
-            // Monta a URL de redirecionamento
-            let redirectUrl = `https://${hostToUse}`;
-            // Adiciona a porta HTTPS apenas se não for a padrão (443)
-            if (port !== 443) {
-                redirectUrl += `:${port}`;
-            }
-            redirectUrl += req.url || '/';
-            res.writeHead(301, { 'Location': redirectUrl });
-            res.end();
-        }).listen(httpRedirectPort, hostname, () => { });
-    }
-    else {
-        // --- MODO HTTP (Original) ---
-        // Cria o servidor HTTP nativo
-        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
-    // @ts-ignore (Propriedades específicas do HTTP/1, HTTP/2 gerencia isso de forma diferente, mas mantemos para o server HTTP padrão)
+    // Sempre criamos um servidor HTTP padrão do Node.js.
+    // Se estivermos em modo SSL (HTTP/3), este servidor será apenas o "backend" local.
+    const server = http_1.default.createServer(requestListener);
+    // Configurações de timeout (aplicam-se ao backend)
+    server.setTimeout(vattsConfig.serverTimeout || 35000);
+    // @ts-ignore
     if (server.maxHeadersCount)
         server.maxHeadersCount = vattsConfig.maxHeadersCount || 100;
     // @ts-ignore
@@ -518,11 +479,49 @@ async function initNativeServer(vattsApp, options, port, hostname) {
     // @ts-ignore
     if (server.requestTimeout)
         server.requestTimeout = vattsConfig.requestTimeout || 30000;
-    server.listen(port, hostname, () => {
-        sendBox({ ...options });
-        msg.end(`${console_1.Colors.Bright}Ready on port ${console_1.Colors.BgGreen} ${exports.config?.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)
+    const isSSL = exports.config.ssl && exports.config.ssl.key && exports.config.ssl.cert;
+    if (isSSL) {
+        // --- MODO SSL (HTTP/3 Proxy Nativo) ---
+        // 1. Definição da Porta do Backend (Onde o Node.js vai rodar escondido)
+        // Se a porta pública for 3000, usamos 3001 para o backend para não dar conflito de porta presa.
+        const backendPort = exports.config.ssl?.backendPort;
+        // 2. Portas Públicas
+        const publicPort = exports.config.port || 443;
+        const redirectPort = exports.config.ssl?.redirectPort || 80;
+        // 3. Inicia o Node.js em localhost (Backend)
+        server.listen(backendPort, '127.0.0.1', () => {
+            try {
+                // 4. Inicia o Proxy Go (HTTP/3 + Fallback H2/H1)
+                // Isso não bloqueia o Node, roda em background via CGO
+                (0, http3_1.default)({
+                    httpPort: `:${redirectPort}`, // Porta para redirecionar HTTP -> HTTPS
+                    httpsPort: `:${publicPort}`, // Porta Principal (UDP/TCP)
+                    backendUrl: `http://127.0.0.1:${backendPort}`, // Para onde enviar o tráfego
+                    certPath: exports.config?.ssl?.cert,
+                    keyPath: exports.config?.ssl?.key
+                });
+                // Atualiza o box de info para mostrar a porta pública correta
+                sendBox({ ...options });
+                msg.end(`${console_1.Colors.Bright}Ready on port ${console_1.Colors.BgGreen} ${publicPort} (HTTP/3 Enabled) ${console_1.Colors.Reset}\n` +
+                    `${console_1.Colors.Dim} ↳ Backend active on 127.0.0.1:${backendPort}${console_1.Colors.Reset}\n` +
+                    `${console_1.Colors.Bright} in ${Date.now() - time}ms${console_1.Colors.Reset}\n`);
+            }
+            catch (err) {
+                console_1.default.error(`${console_1.Colors.FgRed}[Critical] Failed to start Native HTTP/3 Proxy:${console_1.Colors.Reset} ${err.message}`);
+                // Opcional: Fallback ou exit. Geralmente se o SSL falhar, melhor parar.
+                process.exit(1);
+            }
+        });
+    }
+    else {
+        // --- MODO HTTP CLÁSSICO (Sem SSL) ---
+        // Roda direto na porta configurada, exposto para o mundo
+        server.listen(exports.config?.port, hostname, () => {
+            sendBox({ ...options });
+            msg.end(`${console_1.Colors.Bright}Ready on port ${console_1.Colors.BgGreen} ${exports.config?.port} ${console_1.Colors.Reset}${console_1.Colors.Bright} in ${Date.now() - time}ms${console_1.Colors.Reset}\n`);
+        });
+    }
+    // Configura WebSocket (Funciona através do Proxy pois ele suporta upgrade de conexão)
     vattsApp.setupWebSocket(server);
     vattsApp.executeInstrumentation();
     return server;
@@ -618,12 +617,11 @@ ${console_1.Colors.Bright + console_1.Colors.FgCyan}    \\  /  /\\   |   |  /__\
 ${console_1.Colors.Bright + console_1.Colors.FgCyan}     \\/  /~~\\  |   |  .__/ .${console_1.Colors.FgWhite}   \\__/ .__/ ${message}
                                      
                                      `);
-            const actualPort = exports.config?.port || 3000;
             const actualHostname = options.hostname || "0.0.0.0";
             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(vattsApp, options, actualPort, actualHostname);
+            return await initNativeServer(vattsApp, options, actualHostname);
         }
     };
 }

package/dist/index.js

@@ -60,7 +60,6 @@ const crypto_1 = __importDefault(require("crypto")); // Adicionado para gerar ha
 const express_1 = require("./adapters/express");
 const builder_1 = require("./builder");
 const router_1 = require("./router");
-// import { renderAsStream } from './renderer'; // REMOVIDO: Carregamento dinâmico agora
 const http_1 = require("./api/http");
 Object.defineProperty(exports, "VattsRequest", { enumerable: true, get: function () { return http_1.VattsRequest; } });
 Object.defineProperty(exports, "VattsResponse", { enumerable: true, get: function () { return http_1.VattsResponse; } });
@@ -236,33 +235,6 @@ Object.defineProperty(exports, "FrameworkAdapterFactory", { enumerable: true, ge
 var helpers_2 = require("./helpers");
 Object.defineProperty(exports, "app", { enumerable: true, get: function () { return helpers_2.app; } });
 // Função para verificar se o projeto é grande o suficiente para se beneficiar de chunks
-function isLargeProject(projectDir) {
-    try {
-        const srcDir = path_1.default.join(projectDir, 'src');
-        if (!fs_1.default.existsSync(srcDir))
-            return false;
-        let totalFiles = 0;
-        let totalSize = 0;
-        function scanDirectory(dir) {
-            const items = fs_1.default.readdirSync(dir, { withFileTypes: true });
-            for (const item of items) {
-                const fullPath = path_1.default.join(dir, item.name);
-                if (item.isDirectory() && item.name !== 'node_modules' && item.name !== '.git') {
-                    scanDirectory(fullPath);
-                }
-                else if (item.isFile() && /\.(tsx?|jsx?|css|scss|less)$/i.test(item.name)) {
-                    totalFiles++;
-                    totalSize += fs_1.default.statSync(fullPath).size;
-                }
-            }
-        }
-        scanDirectory(srcDir);
-        return totalFiles > 20 || totalSize > 500 * 1024;
-    }
-    catch (error) {
-        return false;
-    }
-}
 // Função para gerar o arquivo de entrada para o esbuild
 function createEntryFile(projectDir, routes, framework) {
     try {
@@ -556,11 +528,24 @@ function vatts(options) {
                     const staticPath = path_1.default.join(dir, '.vatts');
                     const requestPath = pathname.replace('/_vatts/', '');
                     if (!isSuspiciousPathname(requestPath)) {
-                        const filePath = resolveWithin(staticPath, requestPath);
+                        let filePath = resolveWithin(staticPath, requestPath);
+                        let isGzipped = false;
+                        // --- LÓGICA GZIP (Compatibilidade com Otimizador Go) ---
+                        // Se o arquivo solicitado termina em .js e NÃO existe fisicamente (foi deletado pelo otimizador),
+                        // tentamos encontrar a versão .js.gz
+                        if (filePath && !fs_1.default.existsSync(filePath) && filePath.endsWith('.js')) {
+                            const gzipPath = filePath + '.gz';
+                            if (fs_1.default.existsSync(gzipPath)) {
+                                filePath = gzipPath;
+                                isGzipped = true;
+                            }
+                        }
                         // Verifica se existe E se é arquivo
                         if (filePath && fs_1.default.existsSync(filePath) && fs_1.default.statSync(filePath).isFile()) {
                             const stats = fs_1.default.statSync(filePath);
-                            const ext = path_1.default.extname(filePath).toLowerCase();
+                            // Se for GZIP, usamos '.js' para definir o Content-Type correto (application/javascript),
+                            // caso contrário, pegamos a extensão real do arquivo.
+                            const ext = isGzipped ? '.js' : path_1.default.extname(filePath).toLowerCase();
                             const contentTypes = {
                                 '.js': 'application/javascript',
                                 '.css': 'text/css',
@@ -578,14 +563,17 @@ function vatts(options) {
                                 genericRes.header('Expires', '0');
                             }
                             else {
-                                // Em produção, mantemos o cache agressivo (assumindo hash nos arquivos exceto entry points)
-                                // Dica: Se o main.js de prod também não tiver hash, use 'no-cache' nele também
+                                // Em produção, mantemos o cache agressivo
                                 genericRes.header('Cache-Control', 'public, max-age=31536000, immutable');
                             }
+                            // --- HEADER VITAL PARA GZIP ---
+                            if (isGzipped) {
+                                genericRes.header('Content-Encoding', 'gzip');
+                            }
                             const lastModified = stats.mtime.toUTCString();
                             genericRes.header('Last-Modified', lastModified);
                             genericRes.header('Content-Type', contentTypes[ext] || 'text/plain');
-                            // Lógica 304 (Mantida igual, pois ajuda na performance mesmo em dev se o arquivo n mudou nada)
+                            // Lógica 304
                             const ifModifiedSince = req.headers['if-modified-since'];
                             if (ifModifiedSince) {
                                 const requestDate = new Date(ifModifiedSince).getTime();
@@ -612,8 +600,7 @@ function vatts(options) {
                             return; // Encerra aqui com sucesso
                         }
                         else {
-                            // CORREÇÃO 2: Se o arquivo não existe, retornamos 404 AQUI.
-                            // Isso impede que o código continue e caia na rota de renderização do HTML (SPA Fallback)
+                            // CORREÇÃO 2: 404 para assets não encontrados
                             if (adapter.type === 'express') {
                                 res.status(404).send('Vatts Asset Not Found');
                             }

package/dist/react/renderer-react.js

@@ -151,8 +151,6 @@ function obfuscateData(data) {
     const hash = Buffer.from(Date.now().toString()).toString('base64').substring(0, 8);
     return `${hash}.${base64}`;
 }
-// Retorna as URLs dos scripts e CSS
-// Procura em .vatts/ e .vatts/assets/
 function getBuildAssets(req) {
     const projectDir = process.cwd();
     const distDir = path_1.default.join(projectDir, '.vatts');
@@ -173,8 +171,9 @@ function getBuildAssets(req) {
             const fullPath = path_1.default.join(directory, file);
             const stat = fs_1.default.statSync(fullPath);
             if (stat.isFile()) {
-                if (file.endsWith('.js')) {
-                    scripts.push(`${urlPrefix}/${file}`);
+                // MODIFICADO: Aceita .js OU .js.gz
+                if (file.endsWith('.js') || file.endsWith('.js.gz')) {
+                    scripts.push(`${urlPrefix}/${file.replace(".gz", '')}`);
                 }
                 else if (file.endsWith('.css')) {
                     styles.push(`${urlPrefix}/${file}`);
@@ -189,8 +188,9 @@ function getBuildAssets(req) {
             const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
             const manifestFiles = Object.values(manifest);
             scripts = manifestFiles
-                .filter((f) => f.endsWith('.js'))
-                .map((f) => `/_vatts/${f}`);
+                // MODIFICADO: Filtra .js E .js.gz no manifesto
+                .filter((f) => f.endsWith('.js') || f.endsWith('.js.gz'))
+                .map((f) => `/_vatts/${f.replace(".gz", "")}`);
             styles = manifestFiles
                 .filter((f) => f.endsWith('.css'))
                 .map((f) => `/_vatts/${f}`);

package/dist/types.d.ts

@@ -27,6 +27,7 @@ export interface VattsOptions {
 export interface VattsConfig {
     port: number;
     ssl?: {
+        backendPort: number;
         redirectPort: number;
         key: string;
         cert: string;

package/dist/vue/renderer.vue.js

@@ -101,9 +101,9 @@ function extractComponentPreloads(componentPath) {
                 tags.add(`<link rel="preload" as="style" href="${publicUrl}">`);
                 tags.add(`<link rel="stylesheet" href="${publicUrl}">`);
             }
-            else if (['.js'].includes(ext)) {
+            else if (['.js', '.js.gz'].includes(ext)) {
                 // Adicionado suporte para JS
-                tags.add(`<link rel="preload" as="script" href="${publicUrl}">`);
+                tags.add(`<link rel="preload" as="script" href="${publicUrl.replace(".gz", '')}">`);
             }
             else if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.avif'].includes(ext)) {
                 tags.add(`<link rel="preload" as="image" href="${publicUrl}">`);
@@ -331,8 +331,8 @@ function getBuildAssets(req) {
                 return;
             const fullPath = path_1.default.join(directory, file);
             if (fs_1.default.statSync(fullPath).isFile()) {
-                if (file.endsWith('.js'))
-                    scripts.push(`${urlPrefix}/${file}`);
+                if (file.endsWith('.js') || file.endsWith(".js.gz"))
+                    scripts.push(`${urlPrefix}/${file.replace(".gz", '')}`);
                 else if (file.endsWith('.css'))
                     styles.push(`${urlPrefix}/${file}`);
             }
@@ -343,7 +343,7 @@ function getBuildAssets(req) {
         if (fs_1.default.existsSync(manifestPath)) {
             const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
             const manifestFiles = Object.values(manifest);
-            scripts = manifestFiles.filter((f) => f.endsWith('.js')).map((f) => `/_vatts/${f}`);
+            scripts = manifestFiles.filter((f) => f.endsWith('.js') || f.endsWith(".js.gz")).map((f) => `/_vatts/${f.replace('.gz', '')}`);
             styles = manifestFiles.filter((f) => f.endsWith('.css')).map((f) => `/_vatts/${f}`);
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vatts",
-  "version": "1.3.1-test.3",
+  "version": "1.4.1-test.1",
   "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": "mfraz",
@@ -110,6 +110,7 @@
     "chokidar": "^3.6.0",
     "commander": "^14.0.2",
     "esbuild": "^0.27.2",
+    "koffi": "^2.15.1",
     "rollup": "^4.56.0",
     "rollup-plugin-esbuild": "^6.2.1",
     "rollup-plugin-vue": "^6.0.0",
@@ -136,6 +137,6 @@
     "vue-tsc": "^3.2.3"
   },
   "scripts": {
-    "build": "tsc && copyfiles -u 1 \"src/**/*.{vue,d.ts}\" dist"
+    "build": "tsc && copyfiles -u 1 \"src/**/*.{vue,d.ts}\" dist && copyfiles -f \"../../services/core-go/binaries/*.node\" dist/core-go"
   }
 }