vatts 1.2.0-alpha.1 → 1.2.0-test.0

package/dist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * This file is part of the Vatts.js Project.
  * Copyright (c) 2026 itsmuzin
@@ -14,23 +15,64 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import path from 'path';
-import fs from 'fs';
-import crypto from 'crypto'; // Adicionado para gerar hash do cache
-import { ExpressAdapter } from './adapters/express';
-import { buildWithChunks, watchWithChunks } from './builder';
-import { findMatchingBackendRoute, findMatchingRoute, getLayout, getNotFound, loadBackendRoutes, loadLayout, loadNotFound, loadRoutes, processWebSocketRoutes, setupWebSocketUpgrade } from './router';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = exports.FrameworkAdapterFactory = exports.FastifyAdapter = exports.ExpressAdapter = exports.VattsResponse = exports.VattsRequest = void 0;
+exports.default = vatts;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto")); // Adicionado para gerar hash do cache
+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
-import { VattsRequest, VattsResponse } from './api/http';
-import { HotReloadManager } from './hotReload';
-import { FrameworkAdapterFactory } from './adapters/factory';
-import Console, { Colors } from "./api/console";
-import { loadEnv } from './env/env';
+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; } });
+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
-import { executeRpc } from './rpc/server';
-import { RPC_ENDPOINT } from './rpc/types';
-import { config } from "./helpers";
-import detectFramework from "./api/framework";
+const server_1 = require("./rpc/server");
+const types_1 = require("./rpc/types");
+const helpers_1 = require("./helpers");
+const framework_1 = __importDefault(require("./api/framework"));
 // Helpers de segurança para servir arquivos estáticos sem path traversal
 function isSuspiciousPathname(p) {
     try {
@@ -43,9 +85,9 @@ function isSuspiciousPathname(p) {
 }
 function resolveWithin(baseDir, unsafePath) {
     const rel = unsafePath.replace(/^\/+/, '');
-    const absBase = path.resolve(baseDir);
-    const abs = path.resolve(absBase, rel);
-    const baseWithSep = absBase.endsWith(path.sep) ? absBase : absBase + path.sep;
+    const absBase = path_1.default.resolve(baseDir);
+    const abs = path_1.default.resolve(absBase, rel);
+    const baseWithSep = absBase.endsWith(path_1.default.sep) ? absBase : absBase + path_1.default.sep;
     if (abs !== absBase && !abs.startsWith(baseWithSep))
         return null;
     return abs;
@@ -71,13 +113,13 @@ async function handleImageOptimization(req, res, projectDir) {
     if (imageUrl.startsWith('/_vatts/')) {
         // Arquivos de build (assets gerados pelo Rollup)
         const relPath = imageUrl.replace('/_vatts/', '');
-        filePath = resolveWithin(path.join(projectDir, '.vatts'), relPath);
+        filePath = resolveWithin(path_1.default.join(projectDir, '.vatts'), relPath);
     }
     else {
         // Arquivos públicos
-        filePath = resolveWithin(path.join(projectDir, 'public'), imageUrl);
+        filePath = resolveWithin(path_1.default.join(projectDir, 'public'), imageUrl);
     }
-    if (!filePath || !fs.existsSync(filePath)) {
+    if (!filePath || !fs_1.default.existsSync(filePath)) {
         res.status(404).text('Image not found');
         return;
     }
@@ -93,29 +135,29 @@ async function handleImageOptimization(req, res, projectDir) {
     catch (e) {
         // Se não tiver sharp, avisa uma vez e serve o arquivo original
         if (!global.__vatts_sharp_warned) {
-            Console.warn('Package "sharp" not found. Image optimization is disabled. Install it with: npm install sharp');
+            console_1.default.warn('Package "sharp" not found. Image optimization is disabled. Install it with: npm install sharp');
             global.__vatts_sharp_warned = true;
         }
     }
     // Se não tiver Sharp ou parâmetros, serve original
     if (!sharp || (!widthStr && !heightStr && !qualityStr)) {
-        const ext = path.extname(filePath).toLowerCase();
+        const ext = path_1.default.extname(filePath).toLowerCase();
         const contentTypes = {
             '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
             '.webp': 'image/webp', '.avif': 'image/avif', '.gif': 'image/gif',
             '.svg': 'image/svg+xml'
         };
         res.header('Content-Type', contentTypes[ext] || 'application/octet-stream');
-        const fileBuffer = await fs.promises.readFile(filePath);
+        const fileBuffer = await fs_1.default.promises.readFile(filePath);
         res.send(fileBuffer);
         return;
     }
     try {
         // --- SISTEMA DE CACHE EM DISCO (TEMPORÁRIO EM .vatts) ---
-        const cacheDir = path.join(projectDir, '.vatts', 'cache', 'images');
+        const cacheDir = path_1.default.join(projectDir, '.vatts', 'cache', 'images');
         // Garante que a pasta existe (síncrono na primeira vez é ok, ou async)
-        if (!fs.existsSync(cacheDir)) {
-            fs.mkdirSync(cacheDir, { recursive: true });
+        if (!fs_1.default.existsSync(cacheDir)) {
+            fs_1.default.mkdirSync(cacheDir, { recursive: true });
         }
         const width = widthStr ? parseInt(widthStr, 10) : undefined;
         const height = heightStr ? parseInt(heightStr, 10) : undefined;
@@ -123,17 +165,17 @@ async function handleImageOptimization(req, res, projectDir) {
         // Gera um hash único baseado em TODOS os parâmetros
         // Ex: /img.png?w=100&h=200&q=80 -> hash unico
         const cacheKey = `${imageUrl}?w=${width}&h=${height}&q=${quality}`;
-        const hash = crypto.createHash('md5').update(cacheKey).digest('hex');
+        const hash = crypto_1.default.createHash('md5').update(cacheKey).digest('hex');
         // Define a extensão do arquivo de cache
-        const extOriginal = path.extname(filePath).toLowerCase();
+        const extOriginal = path_1.default.extname(filePath).toLowerCase();
         let extOutput = '.webp'; // Padrão é converter para WebP
         // Exceções que não viram WebP
         if (extOriginal === '.svg' || extOriginal === '.gif') {
             extOutput = extOriginal;
         }
-        const cachedFilePath = path.join(cacheDir, `${hash}${extOutput}`);
+        const cachedFilePath = path_1.default.join(cacheDir, `${hash}${extOutput}`);
         // 1. VERIFICA SE JÁ EXISTE NO CACHE
-        if (fs.existsSync(cachedFilePath)) {
+        if (fs_1.default.existsSync(cachedFilePath)) {
             // Serve direto do cache (Disco)
             // console.log(`[Vatts] Serving cached image: ${imageUrl}`);
             const contentTypes = {
@@ -142,7 +184,7 @@ async function handleImageOptimization(req, res, projectDir) {
                 '.gif': 'image/gif'
             };
             res.header('Content-Type', contentTypes[extOutput] || 'application/octet-stream');
-            const cachedBuffer = await fs.promises.readFile(cachedFilePath);
+            const cachedBuffer = await fs_1.default.promises.readFile(cachedFilePath);
             res.send(cachedBuffer);
             return;
         }
@@ -171,44 +213,46 @@ async function handleImageOptimization(req, res, projectDir) {
         // 3. SALVA NO CACHE PARA A PRÓXIMA VEZ
         // Escreve em background para não bloquear totalmente, mas aguarda para segurança
         try {
-            await fs.promises.writeFile(cachedFilePath, optimizedBuffer);
+            await fs_1.default.promises.writeFile(cachedFilePath, optimizedBuffer);
         }
         catch (writeErr) {
-            Console.error('Failed to write image cache:', writeErr);
+            console_1.default.error('Failed to write image cache:', writeErr);
         }
         res.send(optimizedBuffer);
     }
     catch (error) {
-        Console.error('Error optimizing image:', error);
+        console_1.default.error('Error optimizing image:', error);
         res.status(500).text('Image optimization failed');
     }
 }
-// Exporta apenas os tipos e classes para o backend
-export { VattsRequest, VattsResponse };
 // Exporta os adapters para uso manual se necessário
-export { ExpressAdapter } from './adapters/express';
-export { FastifyAdapter } from './adapters/fastify';
-export { FrameworkAdapterFactory } from './adapters/factory';
+var express_2 = require("./adapters/express");
+Object.defineProperty(exports, "ExpressAdapter", { enumerable: true, get: function () { return express_2.ExpressAdapter; } });
+var fastify_1 = require("./adapters/fastify");
+Object.defineProperty(exports, "FastifyAdapter", { enumerable: true, get: function () { return fastify_1.FastifyAdapter; } });
+var factory_2 = require("./adapters/factory");
+Object.defineProperty(exports, "FrameworkAdapterFactory", { enumerable: true, get: function () { return factory_2.FrameworkAdapterFactory; } });
 // Exporta os helpers para facilitar integração
-export { app } from './helpers';
+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.join(projectDir, 'src');
-        if (!fs.existsSync(srcDir))
+        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.readdirSync(dir, { withFileTypes: true });
+            const items = fs_1.default.readdirSync(dir, { withFileTypes: true });
             for (const item of items) {
-                const fullPath = path.join(dir, item.name);
+                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.statSync(fullPath).size;
+                    totalSize += fs_1.default.statSync(fullPath).size;
                 }
             }
         }
@@ -222,25 +266,25 @@ function isLargeProject(projectDir) {
 // Função para gerar o arquivo de entrada para o esbuild
 function createEntryFile(projectDir, routes, framework) {
     try {
-        const tempDir = path.join(projectDir, '.vatts', 'temp');
-        fs.mkdirSync(tempDir, { recursive: true });
-        const entryFilePath = path.join(tempDir, 'entry.client.js');
-        const layout = getLayout();
-        const notFound = getNotFound();
+        const tempDir = path_1.default.join(projectDir, '.vatts', 'temp');
+        fs_1.default.mkdirSync(tempDir, { recursive: true });
+        const entryFilePath = path_1.default.join(tempDir, 'entry.client.js');
+        const layout = (0, router_1.getLayout)();
+        const notFound = (0, router_1.getNotFound)();
         const imports = routes
             .map((route, index) => {
-            const relativePath = path.relative(tempDir, route.componentPath).replace(/\\/g, '/');
+            const relativePath = path_1.default.relative(tempDir, route.componentPath).replace(/\\/g, '/');
             return `import route${index} from '${relativePath}';`;
         })
             .join('\n');
         const layoutImport = layout
-            ? `import LayoutComponent from '${path.relative(tempDir, layout.componentPath).replace(/\\/g, '/')}';`
+            ? `import LayoutComponent from '${path_1.default.relative(tempDir, layout.componentPath).replace(/\\/g, '/')}';`
             : '';
         const notFoundImport = notFound
-            ? `import NotFoundComponent from '${path.relative(tempDir, notFound.componentPath).replace(/\\/g, '/')}';`
+            ? `import NotFoundComponent from '${path_1.default.relative(tempDir, notFound.componentPath).replace(/\\/g, '/')}';`
             : '';
         let componentRegistration;
-        if (config?.pathRouter === true) {
+        if (helpers_1.config?.pathRouter === true) {
             componentRegistration = routes
                 .map((route, index) => `  '${route.componentPath}': route${index} || route${index}.default,`)
                 .join('\n');
@@ -266,12 +310,12 @@ function createEntryFile(projectDir, routes, framework) {
         // Define os nomes dos arquivos baseados no framework
         const entryClientFilename = framework === 'vue' ? 'entry.client.js' : 'entry.client.js';
         const defaultNotFoundFilename = framework === 'vue' ? 'DefaultNotFound.vue' : 'DefaultNotFound.js';
-        const sdkDir = path.dirname(__dirname);
+        const sdkDir = path_1.default.dirname(__dirname);
         // --- MODIFICAÇÃO: Usando a variável 'framework' para definir o diretório (react ou vue) ---
-        const entryClientPath = path.join(sdkDir, 'dist', framework, entryClientFilename);
-        const relativeEntryPath = path.relative(tempDir, entryClientPath).replace(/\\/g, '/');
-        const defaultNotFoundPath = path.join(sdkDir, 'dist', framework, defaultNotFoundFilename);
-        const relativeDefaultNotFoundPath = path.relative(tempDir, defaultNotFoundPath).replace(/\\/g, '/');
+        const entryClientPath = path_1.default.join(sdkDir, 'dist', framework, entryClientFilename);
+        const relativeEntryPath = path_1.default.relative(tempDir, entryClientPath).replace(/\\/g, '/');
+        const defaultNotFoundPath = path_1.default.join(sdkDir, 'dist', framework, defaultNotFoundFilename);
+        const relativeDefaultNotFoundPath = path_1.default.relative(tempDir, defaultNotFoundPath).replace(/\\/g, '/');
         const entryContent = `// Arquivo gerado automaticamente pelo vatts
 ${imports}
 ${layoutImport}
@@ -290,7 +334,7 @@ window.__VATTS_DEFAULT_NOT_FOUND__ = DefaultNotFound;
 import '${relativeEntryPath}';
 `;
         try {
-            fs.writeFileSync(entryFilePath, entryContent);
+            fs_1.default.writeFileSync(entryFilePath, entryContent);
         }
         catch (e) {
             console.error("Error writing entry file", e);
@@ -298,22 +342,22 @@ import '${relativeEntryPath}';
         return entryFilePath;
     }
     catch (e) {
-        Console.error("Error creating entry file:", e);
+        console_1.default.error("Error creating entry file:", e);
         throw e;
     }
 }
-export default function vatts(options) {
+function vatts(options) {
     const { dev = true, dir = process.cwd(), port = 3000, envFiles } = options;
-    loadEnv({ dir, dev, envFiles });
+    (0, env_1.loadEnv)({ dir, dev, envFiles });
     // @ts-ignore
     process.vatts = options;
     // @ts-ignore
     process.env.PORT = options.port;
-    const userWebDir = path.join(dir, 'src', 'web');
-    const userWebRoutesDir = path.join(userWebDir, 'routes');
-    const userBackendRoutesDir = path.join(dir, 'src', 'backend', 'routes');
+    const userWebDir = path_1.default.join(dir, 'src', 'web');
+    const userWebRoutesDir = path_1.default.join(userWebDir, 'routes');
+    const userBackendRoutesDir = path_1.default.join(dir, 'src', 'backend', 'routes');
     // --- DETECÇÃO DO FRAMEWORK ---
-    const framework = detectFramework(dir);
+    const framework = (0, framework_1.default)(dir);
     // --- CARREGAMENTO DO RENDERER ---
     let renderAsStream = require("./renderer").renderAsStream;
     async function executeMiddlewareChain(middlewares, finalHandler, request, params) {
@@ -337,9 +381,9 @@ export default function vatts(options) {
     let hotReloadManager = null;
     let entryPoint;
     const regenerateEntryFile = () => {
-        const newFrontendRoutes = loadRoutes(userWebRoutesDir);
-        const newLayout = loadLayout(userWebDir);
-        const newNotFound = loadNotFound(userWebDir);
+        const newFrontendRoutes = (0, router_1.loadRoutes)(userWebRoutesDir);
+        const newLayout = (0, router_1.loadLayout)(userWebDir);
+        const newNotFound = (0, router_1.loadNotFound)(userWebDir);
         const oldKey = frontendRoutes.map(r => `${r.pattern ?? ''}:${r.componentPath}`).join('|');
         const newKey = newFrontendRoutes.map(r => `${r.pattern ?? ''}:${r.componentPath}`).join('|');
         if (oldKey === newKey) {
@@ -353,44 +397,44 @@ export default function vatts(options) {
         prepare: async () => {
             const isProduction = !dev;
             if (!isProduction) {
-                hotReloadManager = new HotReloadManager(dir);
+                hotReloadManager = new hotReload_1.HotReloadManager(dir);
                 await hotReloadManager.start();
                 hotReloadManager.onBackendApiChange(() => {
-                    loadBackendRoutes(userBackendRoutesDir);
-                    processWebSocketRoutes();
+                    (0, router_1.loadBackendRoutes)(userBackendRoutesDir);
+                    (0, router_1.processWebSocketRoutes)();
                 });
                 hotReloadManager.onFrontendChange(() => {
                     regenerateEntryFile();
                 });
             }
             const now = Date.now();
-            const timee = Console.dynamicLine(`Loading routes and components`);
+            const timee = console_1.default.dynamicLine(`Loading routes and components`);
             const spinnerFrames1 = ['|', '/', '-', '\\'];
             let frameIndex1 = 0;
             const spinner1 = setInterval(() => {
-                timee.update(`   ${Colors.FgYellow}${spinnerFrames1[frameIndex1]}${Colors.Reset}  Loading routes and components...`);
+                timee.update(`   ${console_1.Colors.FgYellow}${spinnerFrames1[frameIndex1]}${console_1.Colors.Reset}  Loading routes and components...`);
                 frameIndex1 = (frameIndex1 + 1) % spinnerFrames1.length;
             }, 100);
-            frontendRoutes = loadRoutes(userWebRoutesDir);
-            loadBackendRoutes(userBackendRoutesDir);
-            processWebSocketRoutes();
-            const layout = loadLayout(userWebDir);
-            const notFound = loadNotFound(userWebDir);
-            const outDir = path.join(dir, '.vatts');
-            fs.mkdirSync(outDir, { recursive: true });
+            frontendRoutes = (0, router_1.loadRoutes)(userWebRoutesDir);
+            (0, router_1.loadBackendRoutes)(userBackendRoutesDir);
+            (0, router_1.processWebSocketRoutes)();
+            const layout = (0, router_1.loadLayout)(userWebDir);
+            const notFound = (0, router_1.loadNotFound)(userWebDir);
+            const outDir = path_1.default.join(dir, '.vatts');
+            fs_1.default.mkdirSync(outDir, { recursive: true });
             entryPoint = createEntryFile(dir, frontendRoutes, framework);
             clearInterval(spinner1);
             timee.end(`Routes and components loaded in ${Date.now() - now}ms`);
             if (isProduction) {
-                const time = Console.dynamicLine(`Starting client build`);
+                const time = console_1.default.dynamicLine(`Starting client build`);
                 const spinnerFrames = ['|', '/', '-', '\\'];
                 let frameIndex = 0;
                 const spinner = setInterval(() => {
-                    time.update(`    ${Colors.FgYellow}${spinnerFrames[frameIndex]}${Colors.Reset}  Building...`);
+                    time.update(`    ${console_1.Colors.FgYellow}${spinnerFrames[frameIndex]}${console_1.Colors.Reset}  Building...`);
                     frameIndex = (frameIndex + 1) % spinnerFrames.length;
                 }, 100);
                 const now = Date.now();
-                await buildWithChunks(entryPoint, outDir, isProduction);
+                await (0, builder_1.buildWithChunks)(entryPoint, outDir, isProduction);
                 const elapsed = Date.now() - now;
                 clearInterval(spinner);
                 time.update("");
@@ -400,18 +444,18 @@ export default function vatts(options) {
                 }
             }
             else {
-                const time = Console.dynamicLine(`  ${Colors.BgYellow} watcher ${Colors.Reset}  Starting client watch`);
+                const time = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} watcher ${console_1.Colors.Reset}  Starting client watch`);
                 // @ts-ignore
-                watchWithChunks(entryPoint, outDir, hotReloadManager).catch(err => {
-                    Console.error(`Error starting watch`, err);
+                (0, builder_1.watchWithChunks)(entryPoint, outDir, hotReloadManager).catch(err => {
+                    console_1.default.error(`Error starting watch`, err);
                 });
                 time.end(`Client Watch started`);
             }
         },
         executeInstrumentation: () => {
-            const instrumentationFile = fs.readdirSync(path.join(dir, 'src')).find(file => /^vattsweb\.(js|ts)$/.test(file));
+            const instrumentationFile = fs_1.default.readdirSync(path_1.default.join(dir, 'src')).find(file => /^vattsweb\.(js|ts)$/.test(file));
             if (instrumentationFile) {
-                const instrumentationPath = path.join(dir, 'src', instrumentationFile);
+                const instrumentationPath = path_1.default.join(dir, 'src', instrumentationFile);
                 const instrumentation = require(instrumentationPath);
                 if (instrumentation.hotReloadListener && typeof instrumentation.hotReloadListener === 'function') {
                     if (hotReloadManager) {
@@ -425,13 +469,13 @@ export default function vatts(options) {
                     instrumentation.default();
                 }
                 else {
-                    Console.warn(`The instrumentation file ${instrumentationFile} does not export a default function.`);
+                    console_1.default.warn(`The instrumentation file ${instrumentationFile} does not export a default function.`);
                 }
             }
         },
         getRequestHandler: () => {
             return async (req, res) => {
-                const adapter = FrameworkAdapterFactory.detectFramework(req, res);
+                const adapter = factory_1.FrameworkAdapterFactory.detectFramework(req, res);
                 const genericReq = adapter.parseRequest(req);
                 const genericRes = adapter.createResponse(res);
                 genericReq.hwebDev = dev;
@@ -440,9 +484,9 @@ export default function vatts(options) {
                 const method = (genericReq.method || 'GET').toUpperCase();
                 const urlObj = new URL(genericReq.url, `http://${hostname}:${port}`);
                 const pathname = urlObj.pathname;
-                if (pathname === RPC_ENDPOINT && method === 'POST') {
+                if (pathname === types_1.RPC_ENDPOINT && method === 'POST') {
                     try {
-                        const result = await executeRpc({
+                        const result = await (0, server_1.executeRpc)({
                             projectDir: dir,
                             request: genericReq
                         }, genericReq.body);
@@ -466,11 +510,11 @@ export default function vatts(options) {
                 }
                 // ---------------------------------------
                 if (pathname !== '/' && !pathname.startsWith('/api/') && !pathname.startsWith('/.vatts')) {
-                    const publicDir = path.join(dir, 'public');
+                    const publicDir = path_1.default.join(dir, 'public');
                     if (!isSuspiciousPathname(pathname)) {
                         const filePath = resolveWithin(publicDir, pathname);
-                        if (filePath && fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-                            const ext = path.extname(filePath).toLowerCase();
+                        if (filePath && fs_1.default.existsSync(filePath) && fs_1.default.statSync(filePath).isFile()) {
+                            const ext = path_1.default.extname(filePath).toLowerCase();
                             const contentTypes = {
                                 '.html': 'text/html',
                                 '.css': 'text/css',
@@ -497,11 +541,11 @@ export default function vatts(options) {
                                 res.sendFile(filePath);
                             }
                             else if (adapter.type === 'fastify') {
-                                const fileContent = fs.readFileSync(filePath);
+                                const fileContent = fs_1.default.readFileSync(filePath);
                                 genericRes.send(fileContent);
                             }
                             else if (adapter.type === 'native') {
-                                const fileContent = fs.readFileSync(filePath);
+                                const fileContent = fs_1.default.readFileSync(filePath);
                                 genericRes.send(fileContent);
                             }
                             return;
@@ -509,12 +553,12 @@ export default function vatts(options) {
                     }
                 }
                 if (pathname.startsWith('/_vatts/')) {
-                    const staticPath = path.join(dir, '.vatts');
+                    const staticPath = path_1.default.join(dir, '.vatts');
                     const requestPath = pathname.replace('/_vatts/', '');
                     if (!isSuspiciousPathname(requestPath)) {
                         const filePath = resolveWithin(staticPath, requestPath);
-                        if (filePath && fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-                            const ext = path.extname(filePath).toLowerCase();
+                        if (filePath && fs_1.default.existsSync(filePath) && fs_1.default.statSync(filePath).isFile()) {
+                            const ext = path_1.default.extname(filePath).toLowerCase();
                             const contentTypes = {
                                 '.js': 'application/javascript',
                                 '.css': 'text/css',
@@ -526,36 +570,36 @@ export default function vatts(options) {
                                 res.sendFile(filePath);
                             }
                             else if (adapter.type === 'fastify') {
-                                const fileContent = fs.readFileSync(filePath);
+                                const fileContent = fs_1.default.readFileSync(filePath);
                                 genericRes.send(fileContent);
                             }
                             else if (adapter.type === 'native') {
-                                const fileContent = fs.readFileSync(filePath);
+                                const fileContent = fs_1.default.readFileSync(filePath);
                                 genericRes.send(fileContent);
                             }
                             return;
                         }
                     }
                 }
-                const backendMatch = findMatchingBackendRoute(pathname, method);
+                const backendMatch = (0, router_1.findMatchingBackendRoute)(pathname, method);
                 if (backendMatch) {
                     try {
                         const handler = backendMatch.route[method];
                         if (handler) {
-                            const hwebReq = new VattsRequest(genericReq);
+                            const hwebReq = new http_1.VattsRequest(genericReq);
                             const hwebRes = await executeMiddlewareChain(backendMatch.route.middleware, handler, hwebReq, backendMatch.params);
                             hwebRes._applyTo(genericRes);
                             return;
                         }
                     }
                     catch (error) {
-                        Console.error(`API route error ${pathname}:`, error);
+                        console_1.default.error(`API route error ${pathname}:`, error);
                         genericRes.status(500).text('Internal server error in API');
                         return;
                     }
                 }
                 // Renderização de Página (Frontend)
-                const pageMatch = findMatchingRoute(pathname);
+                const pageMatch = (0, router_1.findMatchingRoute)(pathname);
                 // Determina o objeto de resposta "cru" para o stream do React
                 // Se for Fastify, o Writable stream está em res.raw. Se for Express/Native, é o próprio res.
                 const rawRes = (res.raw || res);
@@ -567,11 +611,11 @@ export default function vatts(options) {
                             componentPath: '__404__'
                         };
                         // Tenta usar componente 404 customizado se houver
-                        const notFound = getNotFound();
+                        const notFound = (0, router_1.getNotFound)();
                         if (notFound) {
                             // Carrega o componente 404 real para o SSR funcionar
                             try {
-                                const nfModule = require(path.resolve(process.cwd(), notFound.componentPath));
+                                const nfModule = require(path_1.default.resolve(process.cwd(), notFound.componentPath));
                                 // @ts-ignore
                                 notFoundRoute.component = nfModule.default || nfModule;
                             }
@@ -592,7 +636,7 @@ export default function vatts(options) {
                         return;
                     }
                     catch (error) {
-                        Console.error(`Error rendering page 404:`, error);
+                        console_1.default.error(`Error rendering page 404:`, error);
                         genericRes.status(404).text('Page not found');
                         return;
                     }
@@ -608,7 +652,7 @@ export default function vatts(options) {
                     });
                 }
                 catch (error) {
-                    Console.error(`Error rendering page ${pathname}:`, error);
+                    console_1.default.error(`Error rendering page ${pathname}:`, error);
                     // Se o stream já começou, não dá pra enviar erro 500 limpo.
                     // O renderAsStream tenta lidar com isso no onError.
                     if (!rawRes.headersSent) {
@@ -618,9 +662,9 @@ export default function vatts(options) {
             };
         },
         setupWebSocket: (server) => {
-            const isExpressServer = FrameworkAdapterFactory.getCurrentAdapter() instanceof ExpressAdapter;
+            const isExpressServer = factory_1.FrameworkAdapterFactory.getCurrentAdapter() instanceof express_1.ExpressAdapter;
             const actualServer = isExpressServer ? server : (server.server || server);
-            setupWebSocketUpgrade(actualServer, hotReloadManager);
+            (0, router_1.setupWebSocketUpgrade)(actualServer, hotReloadManager);
         },
         stop: () => {
             if (hotReloadManager) {