vatts 1.0.1 → 1.0.2-alpha.2

package/dist/router.js

@@ -39,113 +39,116 @@ const url_1 = require("url");
 const console_1 = __importDefault(require("./api/console"));
 const factory_1 = require("./adapters/factory");
 const http_1 = require("./api/http");
-// --- Roteamento do Frontend ---
-// Guarda todas as rotas de PÁGINA (React) encontradas
-// A rota agora também armazena o caminho do arquivo para ser usado como um ID único no cliente
+// --- Estado Global ---
 let allRoutes = [];
-// Guarda o layout se existir
+let allBackendRoutes = [];
+let allWebSocketRoutes = [];
+// Cache de arquivos para Hot Reload
+const loadedFiles = new Set();
+// Componentes Especiais
 let layoutComponent = null;
-// Guarda o componente 404 personalizado se existir
 let notFoundComponent = null;
-// Cache de arquivos carregados para limpeza
-let loadedRouteFiles = new Set();
-let loadedLayoutFiles = new Set();
-let loadedNotFoundFiles = new Set();
-/**
- * Limpa o cache do require para um arquivo específico
- * @param filePath Caminho do arquivo para limpar
- */
-function clearRequireCache(filePath) {
+// Conexões ativas
+let wsConnections = new Set();
+// --- Helpers de Regex ---
+// Re-implementação da compilação usando Named Groups para segurança e facilidade (como no original, mas cached)
+function compileRoutePatternWithGroups(pattern) {
+    const regexPattern = pattern
+        .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
+        .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
+        .replace(/\/\[\[(\w+)\]\]/g, '(?:/(?<$1>[^/]+))?')
+        .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
+        .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+    return new RegExp(`^${regexPattern}/?$`);
+}
+// --- Gerenciamento de Cache ---
+function safeClearCache(filePath) {
     try {
-        const resolvedPath = require.resolve(filePath);
-        delete require.cache[resolvedPath];
-        // Também limpa arquivos temporários relacionados (apenas se existir no cache)
-        const tempFile = filePath.replace(/\.(tsx|ts|jsx|js)$/, '.temp.$1');
-        const tempResolvedPath = require.cache[require.resolve(tempFile)];
-        if (tempResolvedPath) {
-            delete require.cache[require.resolve(tempFile)];
+        // Tenta deletar direto pela chave do caminho absoluto (mais rápido)
+        if (require.cache[filePath]) {
+            delete require.cache[filePath];
+            return;
+        }
+        // Fallback: resolve o caminho (tem custo de I/O)
+        const resolved = require.resolve(filePath);
+        if (require.cache[resolved]) {
+            delete require.cache[resolved];
         }
     }
-    catch {
-        // Arquivo pode não estar no cache ou não ser resolvível
+    catch (e) {
+        // Ignora erro se arquivo não for resolvível
     }
 }
-// Nota: Suporte apenas para TypeScript (.ts, .tsx). Não tratamos .jsx aqui.
-/**
- * Limpa todo o cache de rotas carregadas
- */
 function clearAllRouteCache() {
-    // Limpa cache das rotas
-    loadedRouteFiles.forEach(filePath => {
-        clearRequireCache(filePath);
-    });
-    loadedRouteFiles.clear();
-    // Limpa cache do layout
-    loadedLayoutFiles.forEach(filePath => {
-        clearRequireCache(filePath);
-    });
-    loadedLayoutFiles.clear();
-    // Limpa cache do notFound
-    loadedNotFoundFiles.forEach(filePath => {
-        clearRequireCache(filePath);
-    });
-    loadedNotFoundFiles.clear();
+    loadedFiles.forEach(file => safeClearCache(file));
+    loadedFiles.clear();
 }
-/**
- * Limpa o cache de um arquivo específico e recarrega as rotas se necessário
- * @param changedFilePath Caminho do arquivo que foi alterado
- */
 function clearFileCache(changedFilePath) {
-    const absolutePath = path_1.default.isAbsolute(changedFilePath) ? changedFilePath : path_1.default.resolve(changedFilePath);
-    // Limpa o cache do arquivo específico
-    clearRequireCache(absolutePath);
-    // Remove das listas de arquivos carregados
-    loadedRouteFiles.delete(absolutePath);
-    loadedLayoutFiles.delete(absolutePath);
-    loadedNotFoundFiles.delete(absolutePath);
+    const absolutePath = path_1.default.resolve(changedFilePath);
+    // Só tenta limpar se realmente já foi carregado (evita I/O desnecessário)
+    if (loadedFiles.has(absolutePath)) {
+        safeClearCache(absolutePath);
+        loadedFiles.delete(absolutePath);
+    }
 }
 /**
- * Carrega o layout.tsx se existir no diretório web
- * @param webDir O diretório web onde procurar o layout
- * @returns O layout carregado ou null se não existir
+ * Hook para ignorar importações de CSS/SCSS/SASS durante o require do servidor.
+ * Isso evita a necessidade de processar arquivos pesados que não afetam a rota.
  */
+function requireWithoutStyles(modulePath) {
+    const extensions = ['.css', '.scss', '.sass', '.less', '.png', '.jpg', '.jpeg', '.gif', '.svg'];
+    const originalHandlers = {};
+    // Salva handlers originais e substitui por no-op
+    extensions.forEach(ext => {
+        originalHandlers[ext] = require.extensions[ext];
+        require.extensions[ext] = (m, filename) => {
+            // Retorna módulo vazio para imports de estilo/assets
+            // @ts-ignore
+            m.exports = {};
+        };
+    });
+    try {
+        // Não chamamos safeClearCache aqui explicitamente; quem chama loadRoutes já deve ter gerenciado o ciclo
+        return require(modulePath);
+    }
+    finally {
+        // Restaura handlers originais
+        extensions.forEach(ext => {
+            if (originalHandlers[ext]) {
+                require.extensions[ext] = originalHandlers[ext];
+            }
+            else {
+                delete require.extensions[ext];
+            }
+        });
+    }
+}
+// --- Carregamento de Layout (Otimizado - Sem I/O de Disco) ---
 function loadLayout(webDir) {
-    const layoutPath = path_1.default.join(webDir, 'layout.tsx');
-    const layoutPathTs = path_1.default.join(webDir, 'layout.ts');
-    const layoutFile = fs_1.default.existsSync(layoutPath) ? layoutPath :
-        fs_1.default.existsSync(layoutPathTs) ? layoutPathTs : null;
+    const extensions = ['layout.tsx', 'layout.ts'];
+    let layoutFile = null;
+    for (const ext of extensions) {
+        const fullPath = path_1.default.join(webDir, ext);
+        if (fs_1.default.existsSync(fullPath)) {
+            layoutFile = fullPath;
+            break;
+        }
+    }
     if (layoutFile) {
         const absolutePath = path_1.default.resolve(layoutFile);
         const componentPath = path_1.default.relative(process.cwd(), layoutFile).replace(/\\/g, '/');
         try {
-            // HACK: Cria uma versão temporária do layout SEM imports de CSS para carregar no servidor
-            const layoutContent = fs_1.default.readFileSync(layoutFile, 'utf8');
-            const tempContent = layoutContent
-                .replace(/import\s+['"][^'"]*\.css['"];?/g, '// CSS import removido para servidor')
-                .replace(/import\s+['"][^'"]*\.scss['"];?/g, '// SCSS import removido para servidor')
-                .replace(/import\s+['"][^'"]*\.sass['"];?/g, '// SASS import removido para servidor');
-            // Escreve um arquivo temporário .temp.tsx ou .temp.ts sem imports de CSS
-            const ext = path_1.default.extname(layoutFile).toLowerCase();
-            const tempFile = layoutFile.replace(/\.(tsx|ts)$/i, '.temp.$1');
-            fs_1.default.writeFileSync(tempFile, tempContent, 'utf8');
-            // Otimização: limpa cache apenas se existir
-            try {
-                const resolvedPath = require.resolve(tempFile);
-                if (require.cache[resolvedPath]) {
-                    delete require.cache[resolvedPath];
-                }
+            // Se já carregamos antes, limpa o cache para garantir reload
+            if (loadedFiles.has(absolutePath)) {
+                safeClearCache(absolutePath);
             }
-            catch { }
-            const layoutModule = require(tempFile);
-            // Remove o arquivo temporário
-            try {
-                fs_1.default.unlinkSync(tempFile);
-            }
-            catch { }
-            const metadata = layoutModule.metadata || null;
-            // Registra o arquivo como carregado
-            loadedLayoutFiles.add(absolutePath);
-            layoutComponent = { componentPath, metadata };
+            // OTIMIZAÇÃO: Carrega em memória ignorando CSS
+            const layoutModule = requireWithoutStyles(layoutFile);
+            loadedFiles.add(absolutePath);
+            layoutComponent = {
+                componentPath,
+                metadata: layoutModule.metadata || null
+            };
             return layoutComponent;
         }
         catch (error) {
@@ -157,322 +160,208 @@ function loadLayout(webDir) {
     layoutComponent = null;
     return null;
 }
-/**
- * Retorna o layout atual se carregado
- */
-function getLayout() {
-    return layoutComponent;
-}
-/**
- * Carrega dinamicamente todas as rotas de frontend do diretório do usuário.
- * @param routesDir O diretório onde as rotas de página estão localizadas.
- * @returns A lista de rotas de página que foram carregadas.
- */
+function getLayout() { return layoutComponent; }
+// --- Carregamento de Rotas Frontend ---
 function loadRoutes(routesDir) {
     if (!fs_1.default.existsSync(routesDir)) {
-        console_1.default.warn(`Frontend routes directory not found at ${routesDir}. No page will be loaded.`);
+        console_1.default.warn(`Frontend routes directory not found at ${routesDir}.`);
         allRoutes = [];
-        return allRoutes;
+        return [];
     }
-    // Otimização: usa função recursiva manual para evitar overhead do recursive: true
-    const routeFiles = [];
-    const scanDirectory = (dir, baseDir = '') => {
+    const loaded = [];
+    const cwdPath = process.cwd();
+    // Função recursiva otimizada
+    const scanAndLoad = (dir) => {
         const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
-            const relativePath = baseDir ? path_1.default.join(baseDir, entry.name) : entry.name;
+            const name = entry.name;
+            // Skip arquivos ocultos ou de sistema para acelerar scan
+            if (name.startsWith('.') || name.startsWith('_'))
+                continue;
+            const fullPath = path_1.default.join(dir, name);
             if (entry.isDirectory()) {
-                // Pula diretório backend inteiro
-                if (entry.name === 'backend')
+                if (name === 'backend')
                     continue;
-                scanDirectory(path_1.default.join(dir, entry.name), relativePath);
+                scanAndLoad(fullPath);
             }
-            else if (entry.isFile()) {
-                // Filtra apenas arquivos .ts/.tsx
-                if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
-                    routeFiles.push(relativePath);
+            else if (entry.isFile() && (name.endsWith('.tsx') || name.endsWith('.ts'))) {
+                try {
+                    const absolutePath = path_1.default.resolve(fullPath);
+                    // OTIMIZAÇÃO CRÍTICA: Só limpa cache se o arquivo já foi carregado antes.
+                    // Isso evita chamadas caras de require.resolve() na inicialização do servidor.
+                    if (loadedFiles.has(absolutePath)) {
+                        safeClearCache(absolutePath);
+                    }
+                    // OTIMIZAÇÃO: Usa requireWithoutStyles também para rotas!
+                    // Isso evita que o Node tente processar imports de CSS/Assets dentro das páginas durante o roteamento.
+                    const routeModule = requireWithoutStyles(absolutePath);
+                    const defaultConfig = routeModule.default;
+                    if (defaultConfig?.pattern && defaultConfig?.component) {
+                        const componentPath = path_1.default.relative(cwdPath, fullPath).replace(/\\/g, '/');
+                        // OTIMIZAÇÃO: Pré-compila a regex aqui
+                        const regex = compileRoutePatternWithGroups(defaultConfig.pattern);
+                        loaded.push({
+                            config: defaultConfig,
+                            componentPath,
+                            regex,
+                            paramNames: [] // Usando named groups na regex, não precisamos mapear manual
+                        });
+                        loadedFiles.add(absolutePath);
+                    }
+                }
+                catch (error) {
+                    console_1.default.error(`Error loading route ${fullPath}:`, error);
                 }
             }
         }
     };
-    scanDirectory(routesDir);
-    const loaded = [];
-    const cwdPath = process.cwd();
-    // Otimização: processa arquivos em lote
-    for (const file of routeFiles) {
-        const filePath = path_1.default.join(routesDir, file);
-        const absolutePath = path_1.default.resolve(filePath);
-        try {
-            // Otimização: limpa cache apenas se já existir
-            const resolvedPath = require.resolve(filePath);
-            if (require.cache[resolvedPath]) {
-                delete require.cache[resolvedPath];
-            }
-            const routeModule = require(filePath);
-            if (routeModule.default?.pattern && routeModule.default?.component) {
-                // Otimização: calcula componentPath apenas uma vez
-                const componentPath = path_1.default.relative(cwdPath, filePath).replace(/\\/g, '/');
-                loaded.push({ ...routeModule.default, componentPath });
-                loadedRouteFiles.add(absolutePath);
-            }
-        }
-        catch (error) {
-            console_1.default.error(`Error loading page route ${filePath}:`, error);
-        }
-    }
+    scanAndLoad(routesDir);
+    // Atualiza variável global e retorna formato esperado pelo sistema (sem a regex exposta para não quebrar tipagem antiga se for estrita)
     allRoutes = loaded;
-    return allRoutes;
+    return allRoutes.map(r => ({ ...r.config, componentPath: r.componentPath }));
 }
-/**
- * Encontra a rota de página correspondente para uma URL.
- * @param pathname O caminho da URL (ex: "/users/123").
- * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
- */
 function findMatchingRoute(pathname) {
+    // OTIMIZAÇÃO: Loop usando regex pré-compilada. Muito mais rápido.
     for (const route of allRoutes) {
-        if (!route.pattern)
-            continue;
-        const regexPattern = route.pattern
-            // [[...param]] → opcional catch-all
-            .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
-            // [...param] → obrigatório catch-all
-            .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
-            // /[[param]] → opcional com barra também opcional
-            .replace(/\/\[\[(\w+)\]\]/g, '(?:/(?<$1>[^/]+))?')
-            // [[param]] → segmento opcional (sem barra anterior)
-            .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
-            // [param] → segmento obrigatório
-            .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
-        // permite / opcional no final
-        const regex = new RegExp(`^${regexPattern}/?$`);
-        const match = pathname.match(regex);
+        const match = pathname.match(route.regex);
         if (match) {
             return {
-                route,
+                route: { ...route.config, componentPath: route.componentPath },
                 params: match.groups || {}
             };
         }
     }
     return null;
 }
-// --- Roteamento do Backend ---
-// Guarda todas as rotas de API encontradas
-let allBackendRoutes = [];
-// Cache de middlewares carregados por diretório
-let loadedMiddlewares = new Map();
-/**
- * Carrega middlewares de um diretório específico
- * @param dir O diretório onde procurar por middleware.ts
- * @returns Array de middlewares encontrados
- */
-function loadMiddlewareFromDirectory(dir) {
-    const middlewares = [];
-    // Procura por middleware.ts, middleware.tsx
-    const middlewarePath = path_1.default.join(dir, 'middleware.ts');
-    const middlewarePathTsx = path_1.default.join(dir, 'middleware.tsx');
-    const middlewareFile = fs_1.default.existsSync(middlewarePath) ? middlewarePath :
-        fs_1.default.existsSync(middlewarePathTsx) ? middlewarePathTsx : null;
-    if (middlewareFile) {
-        try {
-            const absolutePath = path_1.default.resolve(middlewareFile);
-            clearRequireCache(absolutePath);
-            const middlewareModule = require(middlewareFile);
-            // Suporte para export default (função única) ou export { middleware1, middleware2 }
-            if (typeof middlewareModule.default === 'function') {
-                middlewares.push(middlewareModule.default);
-            }
-            else if (middlewareModule.default && Array.isArray(middlewareModule.default)) {
-                middlewares.push(...middlewareModule.default);
-            }
-            else {
-                // Procura por exports nomeados que sejam funções
-                Object.keys(middlewareModule).forEach(key => {
-                    if (key !== 'default' && typeof middlewareModule[key] === 'function') {
-                        middlewares.push(middlewareModule[key]);
+// --- Carregamento de Rotas Backend ---
+// Cache de middlewares simples
+const middlewareCache = new Map();
+function getMiddlewaresForDir(dir) {
+    if (middlewareCache.has(dir))
+        return middlewareCache.get(dir);
+    const files = ['middleware.ts', 'middleware.tsx'];
+    let middlewares = [];
+    for (const file of files) {
+        const fullPath = path_1.default.join(dir, file);
+        if (fs_1.default.existsSync(fullPath)) {
+            try {
+                const absolutePath = path_1.default.resolve(fullPath);
+                if (loadedFiles.has(absolutePath)) {
+                    safeClearCache(absolutePath);
+                }
+                // Middlewares backend não usam requireWithoutStyles pois não devem ter CSS,
+                // e podem precisar de outros módulos backend.
+                const mod = require(fullPath);
+                loadedFiles.add(absolutePath);
+                // Extração robusta de exports
+                if (typeof mod.default === 'function')
+                    middlewares.push(mod.default);
+                else if (Array.isArray(mod.default))
+                    middlewares.push(...mod.default);
+                Object.keys(mod).forEach(key => {
+                    if (key !== 'default' && typeof mod[key] === 'function') {
+                        middlewares.push(mod[key]);
                     }
                 });
+                // Só processa o primeiro arquivo de middleware encontrado na pasta
+                break;
+            }
+            catch (e) {
+                console_1.default.error(`Error loading middleware ${fullPath}`, e);
             }
-        }
-        catch (error) {
-            console_1.default.error(`Error loading middleware ${middlewareFile}:`, error);
         }
     }
+    middlewareCache.set(dir, middlewares);
     return middlewares;
 }
-/**
- * Coleta middlewares do diretório específico da rota (não herda dos pais)
- * @param routeFilePath Caminho completo do arquivo de rota
- * @param backendRoutesDir Diretório raiz das rotas de backend
- * @returns Array com middlewares apenas do diretório da rota
- */
-function collectMiddlewaresForRoute(routeFilePath, backendRoutesDir) {
-    const relativePath = path_1.default.relative(backendRoutesDir, routeFilePath);
-    const routeDir = path_1.default.dirname(path_1.default.join(backendRoutesDir, relativePath));
-    // Carrega middlewares APENAS do diretório específico da rota (não herda dos pais)
-    if (!loadedMiddlewares.has(routeDir)) {
-        const middlewares = loadMiddlewareFromDirectory(routeDir);
-        loadedMiddlewares.set(routeDir, middlewares);
-    }
-    return loadedMiddlewares.get(routeDir) || [];
-}
-/**
- * Carrega dinamicamente todas as rotas de API do diretório de backend.
- * @param backendRoutesDir O diretório onde as rotas de API estão localizadas.
- */
 function loadBackendRoutes(backendRoutesDir) {
     if (!fs_1.default.existsSync(backendRoutesDir)) {
-        // É opcional ter uma API, então não mostramos um aviso se a pasta não existir.
         allBackendRoutes = [];
         return;
     }
-    // Limpa cache de middlewares para recarregar
-    loadedMiddlewares.clear();
-    // Otimização: usa função recursiva manual e coleta middlewares durante o scan
-    const routeFiles = [];
-    const middlewareFiles = new Map(); // dir -> filepath
-    const scanDirectory = (dir, baseDir = '') => {
+    middlewareCache.clear(); // Limpa cache de middleware ao recarregar rotas
+    const loaded = [];
+    const scanAndLoadAPI = (dir) => {
         const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        // Primeiro carrega middleware deste diretório para cachear
+        getMiddlewaresForDir(dir);
         for (const entry of entries) {
-            const relativePath = baseDir ? path_1.default.join(baseDir, entry.name) : entry.name;
+            const name = entry.name;
+            if (name.startsWith('.') || name.startsWith('_'))
+                continue;
+            const fullPath = path_1.default.join(dir, name);
             if (entry.isDirectory()) {
-                scanDirectory(path_1.default.join(dir, entry.name), relativePath);
+                scanAndLoadAPI(fullPath);
             }
-            else if (entry.isFile()) {
-                const isSupported = entry.name.endsWith('.ts') || entry.name.endsWith('.tsx');
-                if (!isSupported)
+            else if (entry.isFile() && (name.endsWith('.ts') || name.endsWith('.tsx'))) {
+                if (name.startsWith('middleware'))
                     continue;
-                // Identifica middlewares durante o scan
-                if (entry.name.startsWith('middleware')) {
-                    const dirPath = path_1.default.dirname(path_1.default.join(backendRoutesDir, relativePath));
-                    middlewareFiles.set(dirPath, path_1.default.join(backendRoutesDir, relativePath));
-                }
-                else {
-                    routeFiles.push(relativePath);
-                }
-            }
-        }
-    };
-    scanDirectory(backendRoutesDir);
-    // Otimização: pré-carrega todos os middlewares em um único passe
-    for (const [dirPath, middlewarePath] of middlewareFiles) {
-        try {
-            const resolvedPath = require.resolve(middlewarePath);
-            if (require.cache[resolvedPath]) {
-                delete require.cache[resolvedPath];
-            }
-            const middlewareModule = require(middlewarePath);
-            const middlewares = [];
-            if (typeof middlewareModule.default === 'function') {
-                middlewares.push(middlewareModule.default);
-            }
-            else if (Array.isArray(middlewareModule.default)) {
-                middlewares.push(...middlewareModule.default);
-            }
-            else {
-                // Exports nomeados
-                for (const key in middlewareModule) {
-                    if (key !== 'default' && typeof middlewareModule[key] === 'function') {
-                        middlewares.push(middlewareModule[key]);
+                try {
+                    const absolutePath = path_1.default.resolve(fullPath);
+                    if (loadedFiles.has(absolutePath)) {
+                        safeClearCache(absolutePath);
                     }
-                }
-            }
-            if (middlewares.length > 0) {
-                loadedMiddlewares.set(dirPath, middlewares);
-            }
-        }
-        catch (error) {
-            console_1.default.error(`Error loading middleware ${middlewarePath}:`, error);
-        }
-    }
-    // Otimização: processa rotas com cache já limpo
-    const loaded = [];
-    for (const file of routeFiles) {
-        const filePath = path_1.default.join(backendRoutesDir, file);
-        try {
-            // Otimização: limpa cache apenas se existir
-            const resolvedPath = require.resolve(filePath);
-            if (require.cache[resolvedPath]) {
-                delete require.cache[resolvedPath];
-            }
-            const routeModule = require(filePath);
-            if (routeModule.default?.pattern) {
-                const routeConfig = { ...routeModule.default };
-                // Se a rota NÃO tem middleware definido, usa os da pasta
-                if (!routeConfig.hasOwnProperty('middleware')) {
-                    const routeDir = path_1.default.dirname(path_1.default.resolve(filePath));
-                    const folderMiddlewares = loadedMiddlewares.get(routeDir);
-                    if (folderMiddlewares && folderMiddlewares.length > 0) {
-                        routeConfig.middleware = folderMiddlewares;
+                    const mod = require(fullPath);
+                    loadedFiles.add(absolutePath);
+                    const config = mod.default;
+                    if (config?.pattern) {
+                        // Aplica middleware automaticamente se não definido
+                        if (!config.middleware) {
+                            const dirMiddlewares = getMiddlewaresForDir(dir);
+                            if (dirMiddlewares.length > 0) {
+                                config.middleware = dirMiddlewares;
+                            }
+                        }
+                        // OTIMIZAÇÃO: Pré-compila regex
+                        loaded.push({
+                            config,
+                            regex: compileRoutePatternWithGroups(config.pattern),
+                            paramNames: []
+                        });
                     }
                 }
-                loaded.push(routeConfig);
+                catch (e) {
+                    console_1.default.error(`Error loading API route ${fullPath}`, e);
+                }
             }
         }
-        catch (error) {
-            console_1.default.error(`Error loading API route ${filePath}:`, error);
-        }
-    }
+    };
+    scanAndLoadAPI(backendRoutesDir);
     allBackendRoutes = loaded;
+    // Processa WebSockets após carregar rotas HTTP
+    processWebSocketRoutes();
 }
-/**
- * Encontra a rota de API correspondente para uma URL e método HTTP.
- * @param pathname O caminho da URL (ex: "/api/users/123").
- * @param method O método HTTP da requisição (GET, POST, etc.).
- * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
- */
 function findMatchingBackendRoute(pathname, method) {
+    const methodUpper = method.toUpperCase();
     for (const route of allBackendRoutes) {
-        // Verifica se a rota tem um handler para o método HTTP atual
-        if (!route.pattern || !route[method.toUpperCase()])
+        // Verifica método antes de rodar regex (otimização barata)
+        // @ts-ignore
+        if (!route.config[methodUpper])
             continue;
-        const regexPattern = route.pattern
-            // [[...param]] → opcional catch-all
-            .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
-            // [...param] → obrigatório catch-all
-            .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
-            // [[param]] → segmento opcional
-            .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
-            // [param] → segmento obrigatório
-            .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
-        const regex = new RegExp(`^${regexPattern}/?$`);
-        const match = pathname.match(regex);
+        const match = pathname.match(route.regex);
         if (match) {
             return {
-                route,
+                route: route.config,
                 params: match.groups || {}
             };
         }
     }
     return null;
 }
-/**
- * Carrega o notFound.tsx se existir no diretório web
- * @param webDir O diretório web onde procurar o notFound
- * @returns O notFound carregado ou null se não existir
- */
+// --- 404 Not Found ---
 function loadNotFound(webDir) {
-    const notFoundPath = path_1.default.join(webDir, 'notFound.tsx');
-    const notFoundPathTs = path_1.default.join(webDir, 'notFound.ts');
-    const notFoundFile = fs_1.default.existsSync(notFoundPath) ? notFoundPath :
-        fs_1.default.existsSync(notFoundPathTs) ? notFoundPathTs : null;
-    if (notFoundFile) {
-        const absolutePath = path_1.default.resolve(notFoundFile);
-        const componentPath = path_1.default.relative(process.cwd(), notFoundFile).replace(/\\/g, '/');
-        try {
-            // Otimização: limpa cache apenas se existir
-            try {
-                const resolvedPath = require.resolve(notFoundFile);
-                if (require.cache[resolvedPath]) {
-                    delete require.cache[resolvedPath];
-                }
+    const files = ['notFound.tsx', 'notFound.ts'];
+    for (const file of files) {
+        const fullPath = path_1.default.join(webDir, file);
+        if (fs_1.default.existsSync(fullPath)) {
+            const absolutePath = path_1.default.resolve(fullPath);
+            const componentPath = path_1.default.relative(process.cwd(), fullPath).replace(/\\/g, '/');
+            if (loadedFiles.has(absolutePath)) {
+                safeClearCache(absolutePath);
             }
-            catch { }
-            // Registra o arquivo como carregado
-            loadedNotFoundFiles.add(absolutePath);
-            notFoundComponent = { componentPath };
-            return notFoundComponent;
-        }
-        catch (error) {
-            console_1.default.error(`Error loading notFound ${notFoundFile}:`, error);
+            // Também usa requireWithoutStyles para o 404
+            requireWithoutStyles(absolutePath);
+            loadedFiles.add(absolutePath);
             notFoundComponent = { componentPath };
             return notFoundComponent;
         }
@@ -480,180 +369,105 @@ function loadNotFound(webDir) {
     notFoundComponent = null;
     return null;
 }
-/**
- * Retorna o componente 404 atual se carregado
- */
-function getNotFound() {
-    return notFoundComponent;
-}
-// --- WebSocket Functions ---
-// Guarda todas as rotas WebSocket encontradas
-let allWebSocketRoutes = [];
-// Conexões WebSocket ativas
-let wsConnections = new Set();
-/**
- * Processa e registra rotas WebSocket encontradas nas rotas backend
- */
+function getNotFound() { return notFoundComponent; }
+// --- WebSocket (Mantendo lógica, otimizando lookup) ---
 function processWebSocketRoutes() {
-    allWebSocketRoutes = [];
-    for (const route of allBackendRoutes) {
-        if (route.WS) {
-            const wsRoute = {
-                pattern: route.pattern,
-                handler: route.WS,
-                middleware: route.middleware
-            };
-            allWebSocketRoutes.push(wsRoute);
-        }
-    }
+    allWebSocketRoutes = allBackendRoutes
+        .filter(r => r.config.WS)
+        .map(r => ({
+        config: r.config,
+        regex: r.regex, // Reusa a regex já compilada da rota HTTP!
+        handler: r.config.WS,
+        middleware: r.config.middleware
+    }));
 }
-/**
- * Encontra a rota WebSocket correspondente para uma URL
- */
 function findMatchingWebSocketRoute(pathname) {
-    for (const route of allWebSocketRoutes) {
-        if (!route.pattern)
-            continue;
-        const regexPattern = route.pattern
-            .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
-            .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
-            .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
-            .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
-        const regex = new RegExp(`^${regexPattern}/?$`);
-        const match = pathname.match(regex);
+    for (const wsRoute of allWebSocketRoutes) {
+        const match = pathname.match(wsRoute.regex);
         if (match) {
             return {
-                route,
+                route: {
+                    pattern: wsRoute.config.pattern,
+                    handler: wsRoute.handler,
+                    middleware: wsRoute.middleware
+                },
                 params: match.groups || {}
             };
         }
     }
     return null;
 }
-/**
- * Trata uma nova conexão WebSocket
- */
 function handleWebSocketConnection(ws, req, hwebReq) {
     if (!req.url)
         return;
     const url = new url_1.URL(req.url, `http://${req.headers.host}`);
-    const pathname = url.pathname;
-    const matchedRoute = findMatchingWebSocketRoute(pathname);
-    if (!matchedRoute) {
+    const match = findMatchingWebSocketRoute(url.pathname);
+    if (!match) {
         ws.close(1000, 'Route not found');
         return;
     }
-    const params = extractWebSocketParams(pathname, matchedRoute.route.pattern);
-    const query = Object.fromEntries(url.searchParams.entries());
     const context = {
         vattsReq: hwebReq,
         ws,
         req,
         url,
-        params,
-        query,
+        params: match.params,
+        query: Object.fromEntries(url.searchParams.entries()),
         send: (data) => {
             if (ws.readyState === ws_1.WebSocket.OPEN) {
-                const message = typeof data === 'string' ? data : JSON.stringify(data);
-                ws.send(message);
+                ws.send(typeof data === 'string' ? data : JSON.stringify(data));
             }
         },
-        close: (code, reason) => {
-            ws.close(code || 1000, reason);
-        },
+        close: (code, reason) => ws.close(code || 1000, reason),
         broadcast: (data, exclude) => {
-            const message = typeof data === 'string' ? data : JSON.stringify(data);
+            const msg = typeof data === 'string' ? data : JSON.stringify(data);
             const excludeSet = new Set(exclude || []);
-            wsConnections.forEach(connection => {
-                if (connection.readyState === ws_1.WebSocket.OPEN && !excludeSet.has(connection)) {
-                    connection.send(message);
+            for (const conn of wsConnections) {
+                if (conn.readyState === ws_1.WebSocket.OPEN && !excludeSet.has(conn)) {
+                    conn.send(msg);
                 }
-            });
+            }
         }
     };
     try {
-        matchedRoute.route.handler(context);
+        match.route.handler(context);
     }
     catch (error) {
         console.error('Error in WebSocket handler:', error);
         ws.close(1011, 'Internal server error');
     }
 }
-/**
- * Extrai parâmetros da URL para WebSocket
- */
-function extractWebSocketParams(pathname, pattern) {
-    const params = {};
-    const regexPattern = pattern
-        .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
-        .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
-        .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
-        .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
-    const regex = new RegExp(`^${regexPattern}/?$`);
-    const match = pathname.match(regex);
-    if (match && match.groups) {
-        Object.assign(params, match.groups);
-    }
-    return params;
-}
-/**
- * Configura WebSocket upgrade no servidor HTTP existente
- * @param server Servidor HTTP (Express, Fastify ou Native)
- * @param hotReloadManager Instância do gerenciador de hot-reload para coordenação
- */
 function setupWebSocketUpgrade(server, hotReloadManager) {
-    // NÃO remove listeners existentes para preservar hot-reload
-    // Em vez disso, coordena com o sistema existente
-    // Verifica se já existe um listener de upgrade
-    const existingListeners = server.listeners('upgrade');
-    // Se não há listeners, ou se o hot-reload ainda não foi configurado, adiciona o nosso
-    if (existingListeners.length === 0) {
-        server.on('upgrade', (request, socket, head) => {
-            handleWebSocketUpgrade(request, socket, head, hotReloadManager);
-        });
-    }
-}
-function handleWebSocketUpgrade(request, socket, head, hotReloadManager) {
-    const adapter = factory_1.FrameworkAdapterFactory.getCurrentAdapter();
-    if (!adapter) {
-        console.error('❌ Framework adapter not detected. Unable to process WebSocket upgrade.');
-        socket.destroy();
+    if (server.listeners('upgrade').length > 0)
         return;
-    }
-    const genericReq = adapter.parseRequest(request);
-    const hwebReq = new http_1.VattsRequest(genericReq);
-    const { pathname } = new url_1.URL(request.url, `http://${request.headers.host}`);
-    // Prioridade 1: Hot reload (sistema interno)
-    if (pathname === '/hweb-hotreload/') {
-        if (hotReloadManager) {
-            hotReloadManager.handleUpgrade(request, socket, head);
-        }
-        else {
+    server.on('upgrade', (request, socket, head) => {
+        const adapter = factory_1.FrameworkAdapterFactory.getCurrentAdapter();
+        if (!adapter) {
             socket.destroy();
+            return;
         }
-        return;
-    }
-    // Prioridade 2: Rotas WebSocket do usuário
-    const matchedRoute = findMatchingWebSocketRoute(pathname);
-    if (matchedRoute) {
-        // Faz upgrade para WebSocket usando noServer
-        const wss = new ws_1.WebSocketServer({
-            noServer: true,
-            perMessageDeflate: false, // Melhor performance
-            maxPayload: 1024 * 1024 // Limite de 1MB
-        });
-        wss.handleUpgrade(request, socket, head, (ws) => {
-            wsConnections.add(ws);
-            ws.on('close', () => {
-                wsConnections.delete(ws);
-            });
-            ws.on('error', (error) => {
-                wsConnections.delete(ws);
+        const { pathname } = new url_1.URL(request.url, `http://${request.headers.host}`);
+        // Prioridade 1: Hot Reload
+        if (pathname === '/hweb-hotreload/') {
+            if (hotReloadManager)
+                hotReloadManager.handleUpgrade(request, socket, head);
+            else
+                socket.destroy();
+            return;
+        }
+        // Prioridade 2: Rotas App
+        const match = findMatchingWebSocketRoute(pathname);
+        if (match) {
+            const wss = new ws_1.WebSocketServer({ noServer: true, perMessageDeflate: false, maxPayload: 1024 * 1024 });
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                wsConnections.add(ws);
+                ws.on('close', () => wsConnections.delete(ws));
+                ws.on('error', () => wsConnections.delete(ws));
+                const hwebReq = new http_1.VattsRequest(adapter.parseRequest(request));
+                handleWebSocketConnection(ws, request, hwebReq);
             });
-            // Processa a conexão
-            handleWebSocketConnection(ws, request, hwebReq);
-        });
-        return;
-    }
-    socket.destroy();
+            return;
+        }
+        socket.destroy();
+    });
 }