nyte 1.0.0

package/dist/index.js

@@ -0,0 +1,515 @@
+"use strict";
+/*
+ * This file is part of the Nyte.js Project.
+ * Copyright (c) 2026 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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.NyteResponse = exports.NyteRequest = void 0;
+exports.default = hweb;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("./adapters/express");
+const builder_1 = require("./builder");
+const router_1 = require("./router");
+const renderer_1 = require("./renderer");
+const http_1 = require("./api/http");
+Object.defineProperty(exports, "NyteRequest", { enumerable: true, get: function () { return http_1.NyteRequest; } });
+Object.defineProperty(exports, "NyteResponse", { enumerable: true, get: function () { return http_1.NyteResponse; } });
+const hotReload_1 = require("./hotReload");
+const factory_1 = require("./adapters/factory");
+const console_1 = __importStar(require("./api/console"));
+// RPC
+const server_1 = require("./rpc/server");
+const types_1 = require("./rpc/types");
+// Exporta os adapters para uso manual se necessário
+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
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "app", { enumerable: true, get: function () { return helpers_1.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);
+        // Considera projeto grande se:
+        // - Mais de 20 arquivos de frontend/style
+        // - Ou tamanho total > 500KB
+        return totalFiles > 20 || totalSize > 500 * 1024;
+    }
+    catch (error) {
+        // Em caso de erro, assume que não é um projeto grande
+        return false;
+    }
+}
+// Função para gerar o arquivo de entrada para o esbuild
+function createEntryFile(projectDir, routes) {
+    try {
+        const tempDir = path_1.default.join(projectDir, '.nyte', 'temp');
+        fs_1.default.mkdirSync(tempDir, { recursive: true });
+        const entryFilePath = path_1.default.join(tempDir, 'entry.client.js');
+        // Verifica se há layout
+        const layout = (0, router_1.getLayout)();
+        // Verifica se há notFound personalizado
+        const notFound = (0, router_1.getNotFound)();
+        // Gera imports dinâmicos para cada componente
+        const imports = routes
+            .map((route, index) => {
+            const relativePath = path_1.default.relative(tempDir, route.componentPath).replace(/\\/g, '/');
+            return `import route${index} from '${relativePath}';`;
+        })
+            .join('\n');
+        // Import do layout se existir
+        const layoutImport = layout
+            ? `import LayoutComponent from '${path_1.default.relative(tempDir, layout.componentPath).replace(/\\/g, '/')}';`
+            : '';
+        // Import do notFound se existir
+        const notFoundImport = notFound
+            ? `import NotFoundComponent from '${path_1.default.relative(tempDir, notFound.componentPath).replace(/\\/g, '/')}';`
+            : '';
+        // Registra os componentes no window para o cliente acessar
+        const componentRegistration = routes
+            .map((route, index) => `  '${route.componentPath}': route${index}.component || route${index}.default?.component,`)
+            .join('\n');
+        // Registra o layout se existir
+        const layoutRegistration = layout
+            ? `window.__HWEB_LAYOUT__ = LayoutComponent.default || LayoutComponent;`
+            : `window.__HWEB_LAYOUT__ = null;`;
+        // Registra o notFound se existir
+        const notFoundRegistration = notFound
+            ? `window.__HWEB_NOT_FOUND__ = NotFoundComponent.default || NotFoundComponent;`
+            : `window.__HWEB_NOT_FOUND__ = null;`;
+        // Caminho correto para o entry.client.tsx
+        const sdkDir = path_1.default.dirname(__dirname); // Vai para a pasta pai de src (onde está o hweb-sdk)
+        const entryClientPath = path_1.default.join(sdkDir, 'src', 'client', 'entry.client.tsx');
+        const relativeEntryPath = path_1.default.relative(tempDir, entryClientPath).replace(/\\/g, '/');
+        // Import do DefaultNotFound do SDK
+        const defaultNotFoundPath = path_1.default.join(sdkDir, 'src', 'client', 'DefaultNotFound.tsx');
+        const relativeDefaultNotFoundPath = path_1.default.relative(tempDir, defaultNotFoundPath).replace(/\\/g, '/');
+        const entryContent = `// Arquivo gerado automaticamente pelo hweb
+${imports}
+${layoutImport}
+${notFoundImport}
+import DefaultNotFound from '${relativeDefaultNotFoundPath}';
+
+// Registra os componentes para o cliente
+window.__HWEB_COMPONENTS__ = {
+${componentRegistration}
+};
+
+// Registra o layout se existir
+${layoutRegistration}
+
+// Registra o notFound se existir
+${notFoundRegistration}
+
+// Registra o DefaultNotFound do hweb
+window.__HWEB_DEFAULT_NOT_FOUND__ = DefaultNotFound;
+
+// Importa e executa o entry.client.tsx
+import '${relativeEntryPath}';
+`;
+        try {
+            fs_1.default.writeFileSync(entryFilePath, entryContent);
+        }
+        catch (e) {
+            console.error("sdfijnsdfnijfsdijnfsdnijsdfnijfsdnijfsdnijfsdn", e);
+        }
+        return entryFilePath;
+    }
+    catch (e) {
+        console_1.default.error("Error creating entry file:", e);
+        throw e;
+    }
+}
+function hweb(options) {
+    const { dev = true, dir = process.cwd(), port = 3000 } = options;
+    // @ts-ignore
+    process.nyte = options;
+    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');
+    /**
+     * Executa middlewares sequencialmente e depois o handler final
+     * @param middlewares Array de middlewares para executar
+     * @param finalHandler Handler final da rota
+     * @param request Requisição do Nyte.js
+     * @param params Parâmetros da rota
+     * @returns Resposta do middleware ou handler final
+     */
+    async function executeMiddlewareChain(middlewares, finalHandler, request, params) {
+        if (!middlewares || middlewares.length === 0) {
+            // Não há middlewares, executa diretamente o handler final
+            return await finalHandler(request, params);
+        }
+        let currentIndex = 0;
+        // Função next que será chamada pelos middlewares
+        const next = async () => {
+            if (currentIndex < middlewares.length) {
+                // Ainda há middlewares para executar
+                const currentMiddleware = middlewares[currentIndex];
+                currentIndex++;
+                return await currentMiddleware(request, params, next);
+            }
+            else {
+                // Todos os middlewares foram executados, chama o handler final
+                return await finalHandler(request, params);
+            }
+        };
+        // Inicia a cadeia de execução
+        return await next();
+    }
+    let frontendRoutes = [];
+    let hotReloadManager = null;
+    let entryPoint;
+    let outfile;
+    // Função para regenerar o entry file
+    const regenerateEntryFile = () => {
+        // Recarrega todas as rotas e componentes
+        frontendRoutes = (0, router_1.loadRoutes)(userWebRoutesDir);
+        (0, router_1.loadLayout)(userWebDir);
+        (0, router_1.loadNotFound)(userWebDir);
+        // Regenera o entry file
+        entryPoint = createEntryFile(dir, frontendRoutes);
+    };
+    return {
+        prepare: async () => {
+            const isProduction = !dev;
+            if (!isProduction) {
+                // Inicia hot reload apenas em desenvolvimento (com suporte ao main)
+                hotReloadManager = new hotReload_1.HotReloadManager(dir);
+                await hotReloadManager.start();
+                // Adiciona callback para recarregar TUDO quando qualquer arquivo mudar
+                hotReloadManager.onBackendApiChange(() => {
+                    (0, router_1.loadBackendRoutes)(userBackendRoutesDir);
+                    (0, router_1.processWebSocketRoutes)(); // Processa rotas WS após recarregar backend
+                });
+                // Adiciona callback para regenerar entry file quando frontend mudar
+                hotReloadManager.onFrontendChange(() => {
+                    regenerateEntryFile();
+                });
+            }
+            const now = Date.now();
+            const timee = console_1.default.dynamicLine(`Loading routes and components`);
+            const spinnerFrames1 = ['|', '/', '-', '\\'];
+            let frameIndex1 = 0;
+            const spinner1 = setInterval(() => {
+                timee.update(`   ${console_1.Colors.FgYellow}${spinnerFrames1[frameIndex1]}${console_1.Colors.Reset}  Loading routes and components...`);
+                frameIndex1 = (frameIndex1 + 1) % spinnerFrames1.length;
+            }, 100); // muda a cada 100ms
+            // ORDEM IMPORTANTE: Carrega TUDO antes de criar o arquivo de entrada
+            frontendRoutes = (0, router_1.loadRoutes)(userWebRoutesDir);
+            (0, router_1.loadBackendRoutes)(userBackendRoutesDir);
+            // Processa rotas WebSocket após carregar backend
+            (0, router_1.processWebSocketRoutes)();
+            // Carrega layout.tsx ANTES de criar o entry file
+            const layout = (0, router_1.loadLayout)(userWebDir);
+            const notFound = (0, router_1.loadNotFound)(userWebDir);
+            const outDir = path_1.default.join(dir, '.nyte');
+            fs_1.default.mkdirSync(outDir, { recursive: true });
+            entryPoint = createEntryFile(dir, frontendRoutes);
+            clearInterval(spinner1);
+            timee.end(`Routes and components loaded in ${Date.now() - now}ms`);
+            if (isProduction) {
+                const time = console_1.default.dynamicLine(`Starting client build`);
+                // Spinner
+                const spinnerFrames = ['|', '/', '-', '\\'];
+                let frameIndex = 0;
+                const spinner = setInterval(() => {
+                    time.update(`    ${console_1.Colors.FgYellow}${spinnerFrames[frameIndex]}${console_1.Colors.Reset}  Building...`);
+                    frameIndex = (frameIndex + 1) % spinnerFrames.length;
+                }, 100); // muda a cada 100ms
+                const now = Date.now();
+                await (0, builder_1.buildWithChunks)(entryPoint, outDir, isProduction);
+                const elapsed = Date.now() - now;
+                clearInterval(spinner); // para o spinner
+                time.update(""); // limpa a linha
+                time.end(`Client build completed in ${elapsed}ms`);
+                // Notifica o hot reload manager que o build foi concluído
+                if (hotReloadManager) {
+                    hotReloadManager.onBuildComplete(true);
+                }
+            }
+            else {
+                const time = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} watcher ${console_1.Colors.Reset}  Starting client watch`);
+                (0, builder_1.watchWithChunks)(entryPoint, outDir, hotReloadManager).catch(err => {
+                    console_1.default.error(`Error starting watch`, err);
+                });
+                time.end(`Client Watch started`);
+            }
+        },
+        executeInstrumentation: () => {
+            // verificar se dir/src/instrumentation.(tsx/jsx/js/ts) existe com regex
+            const instrumentationFile = fs_1.default.readdirSync(path_1.default.join(dir, 'src')).find(file => /^nyteweb\.(tsx|jsx|js|ts)$/.test(file));
+            if (instrumentationFile) {
+                const instrumentationPath = path_1.default.join(dir, 'src', instrumentationFile);
+                // dar require, e executar a função principal do arquivo
+                const instrumentation = require(instrumentationPath);
+                // Registra o listener de hot reload se existir
+                if (instrumentation.hotReloadListener && typeof instrumentation.hotReloadListener === 'function') {
+                    if (hotReloadManager) {
+                        hotReloadManager.setHotReloadListener(instrumentation.hotReloadListener);
+                    }
+                }
+                if (typeof instrumentation === 'function') {
+                    instrumentation();
+                }
+                else if (typeof instrumentation.default === 'function') {
+                    instrumentation.default();
+                }
+                else {
+                    console_1.default.warn(`The instrumentation file ${instrumentationFile} does not export a default function.`);
+                }
+            }
+        },
+        getRequestHandler: () => {
+            return async (req, res) => {
+                // Detecta o framework e cria request/response genéricos
+                const adapter = factory_1.FrameworkAdapterFactory.detectFramework(req, res);
+                const genericReq = adapter.parseRequest(req);
+                const genericRes = adapter.createResponse(res);
+                // Adiciona informações do hweb na requisição genérica
+                genericReq.hwebDev = dev;
+                genericReq.hotReloadManager = hotReloadManager;
+                const { hostname } = req.headers;
+                const method = (genericReq.method || 'GET').toUpperCase();
+                const pathname = new URL(genericReq.url, `http://${hostname}:${port}`).pathname;
+                // RPC endpoint (antes das rotas de backend)
+                if (pathname === types_1.RPC_ENDPOINT && method === 'POST') {
+                    try {
+                        const result = await (0, server_1.executeRpc)({
+                            projectDir: dir,
+                            request: genericReq
+                        }, genericReq.body);
+                        genericRes.header('Content-Type', 'application/json');
+                        genericRes.status(200).send(JSON.stringify(result));
+                        return;
+                    }
+                    catch (error) {
+                        genericRes.header('Content-Type', 'application/json');
+                        genericRes.status(200).send(JSON.stringify({ success: false, error: 'Internal RPC error' }));
+                        return;
+                    }
+                }
+                // 1. Verifica se é WebSocket upgrade para hot reload
+                if (pathname === '/hweb-hotreload/' && genericReq.headers.upgrade === 'websocket' && hotReloadManager) {
+                    // Framework vai chamar o evento 'upgrade' do servidor HTTP
+                    return;
+                }
+                // 2. Primeiro verifica se é um arquivo estático da pasta public
+                if (pathname !== '/' && !pathname.startsWith('/api/') && !pathname.startsWith('/.nyte')) {
+                    const publicDir = path_1.default.join(dir, 'public');
+                    const filePath = path_1.default.join(publicDir, pathname);
+                    if (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',
+                            '.js': 'application/javascript',
+                            '.json': 'application/json',
+                            '.png': 'image/png',
+                            '.jpg': 'image/jpeg',
+                            '.jpeg': 'image/jpeg',
+                            '.gif': 'image/gif',
+                            '.svg': 'image/svg+xml',
+                            '.ico': 'image/x-icon',
+                            '.webp': 'image/webp',
+                            '.mp4': 'video/mp4',
+                            '.webm': 'video/webm',
+                            '.mp3': 'audio/mpeg',
+                            '.wav': 'audio/wav',
+                            '.pdf': 'application/pdf',
+                            '.txt': 'text/plain',
+                            '.xml': 'application/xml',
+                            '.zip': 'application/zip'
+                        };
+                        genericRes.header('Content-Type', contentTypes[ext] || 'application/octet-stream');
+                        // Para arquivos estáticos, usamos o método nativo do framework
+                        if (adapter.type === 'express') {
+                            res.sendFile(filePath);
+                        }
+                        else if (adapter.type === 'fastify') {
+                            const fileContent = fs_1.default.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        }
+                        else if (adapter.type === 'native') {
+                            const fileContent = fs_1.default.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        }
+                        return;
+                    }
+                }
+                // 3. Verifica se é um arquivo estático do .nyte
+                if (pathname.startsWith('/_nyte/')) {
+                    const staticPath = path_1.default.join(dir, '.nyte');
+                    const filePath = path_1.default.join(staticPath, pathname.replace('/_nyte/', ''));
+                    if (fs_1.default.existsSync(filePath)) {
+                        const ext = path_1.default.extname(filePath).toLowerCase();
+                        const contentTypes = {
+                            '.js': 'application/javascript',
+                            '.css': 'text/css',
+                            '.map': 'application/json'
+                        };
+                        genericRes.header('Content-Type', contentTypes[ext] || 'text/plain');
+                        // Para arquivos estáticos, usamos o método nativo do framework
+                        if (adapter.type === 'express') {
+                            res.sendFile(filePath);
+                        }
+                        else if (adapter.type === 'fastify') {
+                            const fileContent = fs_1.default.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        }
+                        else if (adapter.type === 'native') {
+                            const fileContent = fs_1.default.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        }
+                        return;
+                    }
+                }
+                // 4. REMOVIDO: Verificação de arquivos React UMD - não precisamos mais
+                // O React agora será bundlado diretamente no main.js
+                // 5. Verifica se é uma rota de API (backend)
+                const backendMatch = (0, router_1.findMatchingBackendRoute)(pathname, method);
+                if (backendMatch) {
+                    try {
+                        const handler = backendMatch.route[method];
+                        if (handler) {
+                            const hwebReq = new http_1.NyteRequest(genericReq);
+                            // Executa middlewares e depois o handler final
+                            const hwebRes = await executeMiddlewareChain(backendMatch.route.middleware, handler, hwebReq, backendMatch.params);
+                            // Aplica a resposta usando o adapter correto
+                            hwebRes._applyTo(genericRes);
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        console_1.default.error(`API route error ${pathname}:`, error);
+                        genericRes.status(500).text('Internal server error in API');
+                        return;
+                    }
+                }
+                // 6. Por último, tenta renderizar uma página (frontend) ou 404
+                const pageMatch = (0, router_1.findMatchingRoute)(pathname);
+                if (!pageMatch) {
+                    // Em vez de enviar texto simples, renderiza a página 404 React
+                    try {
+                        // Cria uma "rota falsa" para a página 404
+                        const notFoundRoute = {
+                            pattern: '/__404__',
+                            component: () => null, // Componente vazio, será tratado no cliente
+                            componentPath: '__404__'
+                        };
+                        const html = await (0, renderer_1.render)({
+                            req: genericReq,
+                            route: notFoundRoute,
+                            params: {},
+                            allRoutes: frontendRoutes
+                        });
+                        genericRes.status(404).header('Content-Type', 'text/html').send(html);
+                        return;
+                    }
+                    catch (error) {
+                        console_1.default.error(`Error rendering page 404:`, error);
+                        genericRes.status(404).text('Page not found');
+                        return;
+                    }
+                }
+                try {
+                    const html = await (0, renderer_1.render)({
+                        req: genericReq,
+                        route: pageMatch.route,
+                        params: pageMatch.params,
+                        allRoutes: frontendRoutes
+                    });
+                    genericRes.status(200).header('Content-Type', 'text/html').send(html);
+                }
+                catch (error) {
+                    console_1.default.error(`Error rendering page ${pathname}:`, error);
+                    genericRes.status(500).text('Internal server error');
+                }
+            };
+        },
+        // Método para configurar WebSocket upgrade nos servidores Express e Fastify
+        setupWebSocket: (server) => {
+            // Detecta se é um servidor Express ou Fastify
+            const isExpressServer = factory_1.FrameworkAdapterFactory.getCurrentAdapter() instanceof express_1.ExpressAdapter;
+            const actualServer = isExpressServer ? server : (server.server || server);
+            // Usa o sistema coordenado de WebSocket upgrade que integra hot-reload e rotas de usuário
+            (0, router_1.setupWebSocketUpgrade)(actualServer, hotReloadManager);
+        },
+        stop: () => {
+            if (hotReloadManager) {
+                hotReloadManager.stop();
+            }
+        }
+    };
+}

package/dist/loaders.d.ts

@@ -0,0 +1 @@
+export = filename;

package/dist/loaders.js

@@ -0,0 +1,138 @@
+"use strict";
+/*
+ * This file is part of the Nyte.js Project.
+ * Copyright (c) 2026 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs = require('fs');
+const path = require('path');
+const Module = require('module');
+/**
+ * Carrega e processa o tsconfig.json para obter os aliases
+ */
+function loadTsConfigAliases() {
+    const projectDir = process.cwd();
+    const tsconfigPath = path.join(projectDir, 'tsconfig.json');
+    const aliases = {};
+    if (fs.existsSync(tsconfigPath)) {
+        try {
+            const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
+            // Remove comentários JSONC de forma mais robusta
+            let jsonContent = tsconfigContent
+                // Remove comentários de linha // (mas não em strings)
+                .replace(/(?:^|\s)\/\/.*$/gm, '')
+                // Remove comentários de bloco /* */
+                .replace(/\/\*[\s\S]*?\*\//g, '')
+                // Remove vírgulas finais (trailing commas) que JSON não aceita
+                .replace(/,(\s*[}\]])/g, '$1');
+            const tsconfig = JSON.parse(jsonContent);
+            if (tsconfig.compilerOptions?.paths) {
+                const baseUrl = tsconfig.compilerOptions.baseUrl || '.';
+                const basePath = path.resolve(projectDir, baseUrl);
+                // Converte os paths do tsconfig para aliases
+                for (const [alias, paths] of Object.entries(tsconfig.compilerOptions.paths)) {
+                    if (Array.isArray(paths) && paths.length > 0) {
+                        // Remove o /* do final
+                        const cleanAlias = alias.replace(/\/\*$/, '');
+                        const cleanPath = paths[0].replace(/\/\*$/, '');
+                        aliases[cleanAlias] = path.resolve(basePath, cleanPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Silenciosamente ignora erros de parsing do tsconfig
+        }
+    }
+    return aliases;
+}
+/**
+ * Registra loaders customizados para Node.js
+ * Permite importar arquivos não-JS diretamente no servidor
+ */
+function registerLoaders() {
+    // Registra resolver de aliases do tsconfig.json
+    const aliases = loadTsConfigAliases();
+    if (Object.keys(aliases).length > 0) {
+        // Guarda referência ao _resolveFilename atual (pode já ter sido modificado por source-map-support)
+        const originalResolveFilename = Module._resolveFilename;
+        Module._resolveFilename = function (request, parent, isMain, options) {
+            // Verifica se o request começa com algum alias
+            for (const [alias, aliasPath] of Object.entries(aliases)) {
+                if (request === alias || request.startsWith(alias + '/')) {
+                    const relativePath = request.slice(alias.length);
+                    const resolvedPath = path.join(aliasPath, relativePath);
+                    // Tenta resolver com diferentes extensões
+                    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
+                    // Primeiro tenta o caminho exato
+                    if (fs.existsSync(resolvedPath)) {
+                        const stats = fs.statSync(resolvedPath);
+                        if (stats.isFile()) {
+                            // Retorna o caminho resolvido diretamente
+                            request = resolvedPath;
+                            break;
+                        }
+                    }
+                    // Tenta com extensões
+                    let resolved = false;
+                    for (const ext of extensions) {
+                        const pathWithExt = resolvedPath + ext;
+                        if (fs.existsSync(pathWithExt)) {
+                            request = pathWithExt;
+                            resolved = true;
+                            break;
+                        }
+                    }
+                    if (resolved)
+                        break;
+                    // Tenta como diretório com index
+                    for (const ext of extensions) {
+                        const indexPath = path.join(resolvedPath, 'index' + ext);
+                        if (fs.existsSync(indexPath)) {
+                            request = indexPath;
+                            resolved = true;
+                            break;
+                        }
+                    }
+                    if (resolved)
+                        break;
+                }
+            }
+            // Chama o resolver original (que pode ser do source-map-support)
+            return originalResolveFilename.call(this, request, parent, isMain, options);
+        };
+    }
+    // Loader para arquivos Markdown (.md)
+    require.extensions['.md'] = function (module, filename) {
+        const content = fs.readFileSync(filename, 'utf8');
+        module.exports = content;
+    };
+    // Loader para arquivos de texto (.txt)
+    require.extensions['.txt'] = function (module, filename) {
+        const content = fs.readFileSync(filename, 'utf8');
+        module.exports = content;
+    };
+    // Loader para arquivos JSON (já existe nativamente, mas garantimos consistência)
+    // require.extensions['.json'] já existe
+    // Loader para imagens - retorna o caminho do arquivo
+    const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.avif', '.ico', '.bmp', '.svg'];
+    imageExtensions.forEach(ext => {
+        require.extensions[ext] = function (module, filename) {
+            // No servidor, retornamos o caminho do arquivo
+            // O frontend usará o plugin do esbuild para converter em base64
+            module.exports = filename;
+        };
+    });
+}
+module.exports = { registerLoaders };

package/dist/renderer.d.ts

@@ -0,0 +1,14 @@
+import { RouteConfig } from './types';
+import type { GenericRequest } from './types/framework';
+interface RenderOptions {
+    req: GenericRequest;
+    route: RouteConfig & {
+        componentPath: string;
+    };
+    params: Record<string, string>;
+    allRoutes: (RouteConfig & {
+        componentPath: string;
+    })[];
+}
+export declare function render({ req, route, params, allRoutes }: RenderOptions): Promise<string>;
+export {};