vatts 1.0.2-alpha.3 → 1.0.2-alpha.4

package/dist/bin/vatts.js

@@ -22,14 +22,17 @@ require('ts-node').register();
 const { registerLoaders } = require('../loaders');
 registerLoaders();
 const { program } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const { Writable } = require('stream');
+// Importa o Console do framework
+const ConsoleModule = require('../api/console');
+const Console = ConsoleModule.default;
+const { Levels, Colors } = ConsoleModule;
 program
     .version('1.0.0')
     .description('CLI to manage the application.');
-// --- Comando DEV ---
-const fs = require('fs');
-const path = require('path');
-// 'program' já deve estar definido no seu arquivo
-// const { program } = require('commander');
+// --- Helpers ---
 /**
  * Função centralizada para iniciar a aplicação
  * @param {object} options - Opções vindas do commander
@@ -45,84 +48,75 @@ function initializeApp(options, isDev) {
     };
     // 1. Verifica se a flag --ssl foi ativada
     if (options.ssl) {
-        const C = require("../api/console");
-        const { Levels } = C;
-        const Console = C.default;
         const sslDir = path.resolve(process.cwd(), 'certs');
-        const keyPath = path.join(sslDir, 'key.pem'); // Padrão 1: key.pem
-        const certPath = path.join(sslDir, 'cert.pem'); // Padrão 2: cert.pem
-        // (Você pode mudar para 'cert.key' se preferir, apenas ajuste os nomes aqui)
+        const keyPath = path.join(sslDir, 'key.pem');
+        const certPath = path.join(sslDir, 'cert.pem');
         // 2. Verifica se os arquivos existem
         if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
             appOptions.ssl = {
                 key: keyPath,
                 cert: certPath
             };
-            // 3. Adiciona a porta de redirecionamento (útil para o initNativeServer)
+            // 3. Adiciona a porta de redirecionamento
             appOptions.ssl.redirectPort = options.httpRedirectPort || 80;
         }
         else {
-            Console.logWithout(Levels.ERROR, null, `Ensure that './certs/key.pem' and './certs/cert.pem' exist.`, `--ssl flag was used, but the files were not found.`);
-            process.exit(1); // Encerra o processo com erro
+            Console.error(`SSL Error: Ensure that './certs/key.pem' and './certs/cert.pem' exist.`);
+            process.exit(1);
         }
     }
     // 4. Inicia o helper com as opções
-    const teste = require("../helpers");
-    const t = teste.default(appOptions);
-    t.init();
+    const helperModule = require("../helpers");
+    const helper = helperModule.default(appOptions);
+    helper.init();
 }
-// --- Comando DEV ---
-program
-    .command('dev')
-    .description('Starts the application in development mode.')
-    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
-    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
-    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
-    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
-    .action((options) => {
-    initializeApp(options, true); // Chama a função com dev: true
-});
-// --- Comando START (Produção) ---
-program
-    .command('start')
-    .description('Starts the application in production mode.')
-    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
-    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
-    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
-    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
-    .action((options) => {
-    initializeApp(options, false); // Chama a função com dev: false
-});
 /**
  * Função corrigida para copiar diretórios recursivamente.
- * Ela agora verifica se um item é um arquivo ou um diretório.
  */
 function copyDirRecursive(src, dest) {
     try {
-        // Garante que o diretório de destino exista
         fs.mkdirSync(dest, { recursive: true });
-        // Usamos { withFileTypes: true } para evitar uma chamada extra de fs.statSync
         const entries = fs.readdirSync(src, { withFileTypes: true });
         for (let entry of entries) {
             const srcPath = path.join(src, entry.name);
             const destPath = path.join(dest, entry.name);
             if (entry.isDirectory()) {
-                // Se for um diretório, chama a si mesma (recursão)
                 copyDirRecursive(srcPath, destPath);
             }
             else {
-                // Se for um arquivo, apenas copia
                 fs.copyFileSync(srcPath, destPath);
             }
         }
     }
     catch (error) {
-        console.error(`❌ Erro ao copiar ${src} para ${dest}:`, error);
-        // Lança o erro para parar o processo de exportação se a cópia falhar
+        Console.error(`Error copying ${src} to ${dest}:`, error);
         throw error;
     }
 }
-// --- INÍCIO DO SEU CÓDIGO (AGORA CORRIGIDO) ---
+// --- Comandos ---
+// Comando DEV
+program
+    .command('dev')
+    .description('Starts the application in development mode.')
+    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
+    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
+    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
+    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
+    .action((options) => {
+    initializeApp(options, true);
+});
+// Comando START (Produção)
+program
+    .command('start')
+    .description('Starts the application in production mode.')
+    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
+    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
+    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
+    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
+    .action((options) => {
+    initializeApp(options, false);
+});
+// Comando EXPORT
 program
     .command('export')
     .description('Exports the application as static HTML to the "exported" folder.')
@@ -132,94 +126,82 @@ program
     .option('--output-h-data <file>', 'Write the data-h value from <script id="__vatts_data__" data-h="..."> into this file')
     .action(async (options) => {
     const projectDir = process.cwd();
-    // Resolve output:
-    // - se vier absoluto, usa como está
-    // - se vier relativo, resolve a partir do projeto
+    // Resolve output
     const outputInput = typeof options.output === 'string' && options.output.trim().length
         ? options.output.trim()
         : 'exported';
     const exportDir = path.isAbsolute(outputInput)
         ? path.resolve(outputInput)
         : path.resolve(projectDir, outputInput);
-    // Proteções: nunca permitir apagar a raiz do drive (ex: D:\) ou o root do SO (ex: C:\)
     const exportDirResolved = path.resolve(exportDir);
-    const exportDirRoot = path.parse(exportDirResolved).root; // ex: 'D:\\'
+    const exportDirRoot = path.parse(exportDirResolved).root;
     const projectDirResolved = path.resolve(projectDir);
     if (exportDirResolved === exportDirRoot) {
-        throw new Error(`Refusing to use output directory at drive root: ${exportDirResolved}`);
+        Console.error(`Refusing to use output directory at drive root: ${exportDirResolved}`);
+        process.exit(1);
     }
-    // Também evita `--output .` ou `--output ..` que cairia no diretório do projeto (perigoso)
-    // Regra: output precisa estar dentro do projeto, ou dentro de uma subpasta do projeto.
-    // (mantém comportamento esperado e evita deletar o repo inteiro por acidente)
     const relExportToProject = path.relative(projectDirResolved, exportDirResolved);
     if (relExportToProject === '' || relExportToProject === '.' || relExportToProject.startsWith('..')) {
-        throw new Error(`Refusing to export to ${exportDirResolved}. Use a subfolder like "exported" or an explicit path inside the project.`);
+        Console.error(`Refusing to export to ${exportDirResolved}. Use a subfolder like "exported" or an explicit path inside the project.`);
+        process.exit(1);
     }
-    // assetsDir: sempre relativo ao exportDir (evita escrever fora sem querer)
-    // Permite usar '.' (raiz do output)
+    // assetsDir
     const assetsDirInputRaw = typeof options.assetsDir === 'string' ? options.assetsDir : '.vatts';
     const assetsDirInput = assetsDirInputRaw.trim().length ? assetsDirInputRaw.trim() : '.';
     const assetsDirResolved = path.resolve(exportDirResolved, assetsDirInput);
     const relAssetsToExport = path.relative(exportDirResolved, assetsDirResolved);
     if (relAssetsToExport.startsWith('..') || path.isAbsolute(relAssetsToExport)) {
-        throw new Error(`Invalid --assets-dir: must be inside output directory. Received: ${assetsDirInputRaw}`);
+        Console.error(`Invalid --assets-dir: must be inside output directory. Received: ${assetsDirInputRaw}`);
+        process.exit(1);
     }
-    // Normaliza a pasta para uso em URL no HTML
-    // Se assets-dir for '.', relAssetsToExport vira '' e assetsBaseHref vira './'
     const assetsDirUrl = relAssetsToExport.split(path.sep).join('/').replace(/^\.?\/?/, '');
-    const assetsBaseHref = './' + (assetsDirUrl.length ? assetsDirUrl + '/' : '');
-    console.log('🚀 Starting export...\n');
+    const assetsBaseHref = '/.' + (assetsDirUrl.length ? assetsDirUrl + '/' : '');
+    Console.info('Starting export process...');
     try {
-        // 1. Cria a pasta exported (limpa se já existir)
+        // 1. Limpa pasta de exportação
         if (fs.existsSync(exportDirResolved)) {
-            console.log('🗑️  Cleaning existing export folder...');
+            Console.info('Cleaning existing export folder...');
             fs.rmSync(exportDirResolved, { recursive: true, force: true });
         }
         fs.mkdirSync(exportDirResolved, { recursive: true });
-        console.log('✅ Export folder created\n');
-        // 2. Inicializa e prepara o build
-        console.log('🔨 Building application...');
-        // ATENÇÃO: Ajuste o caminho deste 'require' conforme a estrutura do seu projeto!
-        const teste = require("../helpers");
-        const app = teste.default({ dev: false, port: 3000, hostname: '0.0.0.0', framework: 'native' });
+        // 2. Build
+        Console.info('Building application...');
+        const helperModule = require("../helpers");
+        // Usando dev: false para produção
+        const app = helperModule.default({ dev: false, port: 3000, hostname: '0.0.0.0', framework: 'native' });
         await app.prepare();
-        console.log('✅ Build complete\n');
+        Console.success('Build complete.');
+        // 3. Copia JavaScript
         const distDir = path.join(projectDirResolved, '.vatts');
         if (fs.existsSync(distDir)) {
-            console.log('📦 Copying JavaScript files...');
+            Console.info('Copying JavaScript files...');
             const exportDistDir = assetsDirResolved;
             copyDirRecursive(distDir, exportDistDir);
-            console.log(`✅ JavaScript files copied to: ${path.relative(exportDirResolved, exportDistDir) || '.'}\n`);
         }
-        // 4. Copia a pasta public se existir
+        // 4. Copia Public
         const publicDir = path.join(projectDirResolved, 'public');
         if (fs.existsSync(publicDir)) {
-            console.log('📁 Copying public files...');
-            const exportPublicDir = path.join(exportDirResolved, 'public');
-            copyDirRecursive(publicDir, exportPublicDir);
-            console.log('✅ Public files copied\n');
+            Console.info('Copying public files...');
+            copyDirRecursive(publicDir, exportDirResolved);
         }
-        // 5. Gera o index.html (opcional) / ou só renderiza para extrair h-data
+        // 5. Gera index.html
         const shouldExtractHData = typeof options.outputHData === 'string' && options.outputHData.trim().length > 0;
         const shouldRenderHtml = Boolean(options.html) || shouldExtractHData;
         if (shouldRenderHtml) {
             const writeHtmlToDisk = Boolean(options.html);
             if (writeHtmlToDisk) {
-                console.log('📝 Generating index.html...');
+                Console.info('Generating index.html...');
             }
             else {
-                console.log('🧩 Rendering HTML to extract h-data (--output-h-data)...');
+                Console.info('Rendering HTML for h-data extraction...');
             }
-            // ATENÇÃO: Ajuste os caminhos destes 'requires' conforme a estrutura do seu projeto!
-            const { render } = require('../renderer');
+            const { renderAsStream } = require('../renderer');
             const { loadRoutes, loadLayout, loadNotFound } = require('../router');
-            // Carrega as rotas para gerar o HTML
             const userWebDir = path.join(projectDirResolved, 'src', 'web');
             const userWebRoutesDir = path.join(userWebDir, 'routes');
             const routes = loadRoutes(userWebRoutesDir);
             loadLayout(userWebDir);
             loadNotFound(userWebDir);
-            // Gera HTML para a rota raiz
             const rootRoute = routes.find(r => r.pattern === '/') || routes[0];
             if (rootRoute) {
                 const mockReq = {
@@ -229,49 +211,58 @@ program
                     hwebDev: false,
                     hotReloadManager: null
                 };
-                const html = await render({
+                let html = '';
+                let resolveStream;
+                const streamComplete = new Promise(r => resolveStream = r);
+                const mockRes = new Writable({
+                    write(chunk, encoding, callback) {
+                        html += chunk.toString();
+                        callback();
+                    }
+                });
+                mockRes.setHeader = () => { };
+                mockRes.statusCode = 200;
+                mockRes.on('finish', () => {
+                    resolveStream();
+                });
+                await renderAsStream({
                     req: mockReq,
+                    res: mockRes,
                     route: rootRoute,
                     params: {},
                     allRoutes: routes
                 });
+                await streamComplete;
                 if (shouldExtractHData) {
                     const m = html.match(/<script\b[^>]*\bid=["']__vatts_data__["'][^>]*\bdata-h=["']([^"']*)["'][^>]*>/i);
                     if (!m || typeof m[1] !== 'string') {
                         throw new Error('Could not find <script id="__vatts_data__" data-h="..."> in rendered HTML.');
                     }
                     const hDataValue = m[1];
-                    // O path do arquivo é relativo ao projeto por padrão
                     const outputHDataPathInput = options.outputHData.trim();
                     const outputHDataPath = path.isAbsolute(outputHDataPathInput)
                         ? path.resolve(outputHDataPathInput)
                         : path.resolve(projectDirResolved, outputHDataPathInput);
                     fs.mkdirSync(path.dirname(outputHDataPath), { recursive: true });
                     fs.writeFileSync(outputHDataPath, hDataValue, 'utf8');
-                    console.log(`✅ h-data written to: ${outputHDataPath}`);
+                    Console.success(`h-data written to: ${path.relative(projectDirResolved, outputHDataPath)}`);
                 }
                 if (writeHtmlToDisk) {
                     const scriptReplaced = html.replace(/\/_vatts\//g, assetsBaseHref);
                     const indexPath = path.join(exportDirResolved, 'index.html');
                     fs.writeFileSync(indexPath, scriptReplaced, 'utf8');
-                    console.log('✅ index.html generated\n');
-                }
-                else {
-                    console.log('✅ HTML rendered (no index.html written)\n');
+                    Console.success('index.html generated.');
                 }
             }
         }
         else {
-            console.log('⏭️  Skipping index.html generation (--no-html)\n');
+            Console.info('Skipping index.html generation.');
         }
-        console.log('🎉 Export completed successfully!');
-        console.log(`📂 Files exported to: ${exportDirResolved}\n`);
+        Console.success(`Export completed successfully to: ${path.relative(projectDirResolved, exportDirResolved)}`);
     }
     catch (error) {
-        // Logar o erro completo (com stack trace) é mais útil
-        console.error('❌ Error during export:', error);
+        Console.error('Error during export:', error);
         process.exit(1);
     }
 });
-// Faz o "parse" dos argumentos passados na linha de comando
 program.parse(process.argv);

package/dist/builder.js

@@ -304,7 +304,8 @@ function createRollupConfig(entryPoint, outdir, isProduction) {
             replace({
                 preventAssignment: true,
                 values: {
-                    'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development')
+                    'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development'),
+                    'proccess.env.PORT': JSON.stringify(process.vatts.port || 3000)
                 }
             }),
             tsconfigPathsPlugin(process.cwd()),

package/dist/client/clientRouter.d.ts

@@ -1,58 +1,15 @@
-export interface RouterEvents {
-    beforeNavigate?: (url: string) => boolean | Promise<boolean>;
-    afterNavigate?: (url: string) => void;
-}
-declare class Router {
-    private events;
+type RouteListener = () => void;
+export declare class Router {
     private listeners;
-    /**
-     * Navega para uma nova rota
-     */
-    push(url: string): Promise<void>;
-    /**
-     * Substitui a entrada atual do histórico
-     */
-    replace(url: string): Promise<void>;
-    /**
-     * Volta uma página no histórico
-     */
-    back(): void;
-    /**
-     * Avança uma página no histórico
-     */
-    forward(): void;
-    /**
-     * Recarrega a página atual (re-renderiza o componente)
-     */
-    refresh(): void;
-    /**
-     * Obtém a URL atual
-     */
+    constructor();
     get pathname(): string;
-    /**
-     * Obtém os query parameters atuais
-     */
-    get query(): URLSearchParams;
-    /**
-     * Obtém a URL completa atual
-     */
-    get url(): string;
-    /**
-     * Adiciona event listeners para eventos de roteamento
-     */
-    on(events: RouterEvents): void;
-    /**
-     * Remove event listeners
-     */
-    off(): void;
-    /**
-     * Adiciona um listener para mudanças de rota
-     */
-    subscribe(listener: () => void): () => void;
-    /**
-     * Dispara evento de navegação para todos os listeners
-     */
-    private triggerNavigation;
+    get search(): string;
+    get hash(): string;
+    push(path: string): void;
+    replace(path: string): void;
+    back(): void;
+    subscribe(listener: RouteListener): () => void;
+    private notify;
 }
 export declare const router: Router;
-export default router;
+export {};

package/dist/client/clientRouter.js

@@ -16,116 +16,61 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.router = void 0;
+exports.router = exports.Router = void 0;
 class Router {
     constructor() {
-        this.events = {};
         this.listeners = new Set();
-    }
-    /**
-     * Navega para uma nova rota
-     */
-    async push(url) {
-        // Callback antes de navegar
-        if (this.events.beforeNavigate) {
-            const shouldProceed = await this.events.beforeNavigate(url);
-            if (shouldProceed === false)
-                return;
-        }
-        // Atualiza a URL na barra de endereço
-        window.history.pushState({ path: url }, '', url);
-        // Dispara evento para o roteador capturar de forma assíncrona
-        setTimeout(() => this.triggerNavigation(), 0);
-        // Callback após navegar
-        if (this.events.afterNavigate) {
-            this.events.afterNavigate(url);
-        }
-    }
-    /**
-     * Substitui a entrada atual do histórico
-     */
-    async replace(url) {
-        // Callback antes de navegar
-        if (this.events.beforeNavigate) {
-            const shouldProceed = await this.events.beforeNavigate(url);
-            if (shouldProceed === false)
-                return;
-        }
-        // Substitui a URL atual no histórico
-        window.history.replaceState({ path: url }, '', url);
-        // Dispara evento para o roteador capturar de forma assíncrona
-        setTimeout(() => this.triggerNavigation(), 0);
-        // Callback após navegar
-        if (this.events.afterNavigate) {
-            this.events.afterNavigate(url);
+        // Só adiciona listener no lado do cliente
+        if (typeof window !== 'undefined') {
+            window.addEventListener('popstate', () => {
+                this.notify();
+            });
         }
     }
-    /**
-     * Volta uma página no histórico
-     */
-    back() {
-        window.history.back();
-    }
-    /**
-     * Avança uma página no histórico
-     */
-    forward() {
-        window.history.forward();
-    }
-    /**
-     * Recarrega a página atual (re-renderiza o componente)
-     */
-    refresh() {
-        setTimeout(() => this.triggerNavigation(), 0);
-    }
-    /**
-     * Obtém a URL atual
-     */
     get pathname() {
+        if (typeof window === 'undefined') {
+            return '/'; // Retorno seguro para SSR
+        }
         return window.location.pathname;
     }
-    /**
-     * Obtém os query parameters atuais
-     */
-    get query() {
-        return new URLSearchParams(window.location.search);
+    get search() {
+        if (typeof window === 'undefined') {
+            return '';
+        }
+        return window.location.search;
+    }
+    get hash() {
+        if (typeof window === 'undefined') {
+            return '';
+        }
+        return window.location.hash;
     }
-    /**
-     * Obtém a URL completa atual
-     */
-    get url() {
-        return window.location.href;
+    push(path) {
+        if (typeof window !== 'undefined') {
+            window.history.pushState({}, '', path);
+            this.notify();
+        }
     }
-    /**
-     * Adiciona event listeners para eventos de roteamento
-     */
-    on(events) {
-        this.events = { ...this.events, ...events };
+    replace(path) {
+        if (typeof window !== 'undefined') {
+            window.history.replaceState({}, '', path);
+            this.notify();
+        }
     }
-    /**
-     * Remove event listeners
-     */
-    off() {
-        this.events = {};
+    back() {
+        if (typeof window !== 'undefined') {
+            window.history.back();
+        }
     }
-    /**
-     * Adiciona um listener para mudanças de rota
-     */
     subscribe(listener) {
         this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
     }
-    /**
-     * Dispara evento de navegação para todos os listeners
-     */
-    triggerNavigation() {
-        // Dispara o evento nativo para o roteador do hweb capturar
-        window.dispatchEvent(new PopStateEvent('popstate'));
-        // Notifica todos os listeners customizados
+    notify() {
         this.listeners.forEach(listener => listener());
     }
 }
-// Instância singleton do router
+exports.Router = Router;
 exports.router = new Router();
-// Para compatibilidade, também exporta como default
-exports.default = exports.router;

package/dist/client/rpc.d.ts

@@ -17,7 +17,7 @@ export type RpcClient<TApi extends Record<string, any> = Record<string, any>> =
  * Typing:
  * - Without a generic: `const api = importServer('...')` -> `api.anyFn<MyReturn>()`
  * - With a generic: `importServer<typeof import('../../backend/helper')>('...')`
- *   gives argument + default return types, while still allowing overrides.
+ * gives argument + default return types, while still allowing overrides.
  *
  * Note: server functions can be defined as `(req, ...args)`; the first arg is injected
  * by the server, so the client signature automatically drops that first parameter.

package/dist/client/rpc.js

@@ -28,6 +28,21 @@ function asErrorMessage(err) {
         return 'Unknown error';
     }
 }
+// Detecta se estamos rodando no Node.js
+const isServer = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+function getRpcEndpoint() {
+    if (isServer) {
+        // Tenta pegar a porta das variáveis de ambiente ou usa 3000 como fallback.
+        // Nota: Se você usar uma porta customizada no vatts.config.ts sem setar ENV,
+        // precisará garantir que process.env.PORT esteja alinhado.
+        const port = process.env.PORT || 3000;
+        // Em SSR, sempre usamos HTTP e Loopback IP (127.0.0.1) para garantir
+        // que a requisição chegue no próprio servidor localmente sem sair pra rede externa.
+        return `http://127.0.0.1:${port}${types_1.RPC_ENDPOINT}`;
+    }
+    // No cliente (browser), URL relativa funciona perfeitamente
+    return types_1.RPC_ENDPOINT;
+}
 /**
  * `importServer("src/backend/index.ts")` returns a Proxy where every property is
  * a function that performs a POST to `/api/rpc`.
@@ -35,7 +50,7 @@ function asErrorMessage(err) {
  * Typing:
  * - Without a generic: `const api = importServer('...')` -> `api.anyFn<MyReturn>()`
  * - With a generic: `importServer<typeof import('../../backend/helper')>('...')`
- *   gives argument + default return types, while still allowing overrides.
+ * gives argument + default return types, while still allowing overrides.
  *
  * Note: server functions can be defined as `(req, ...args)`; the first arg is injected
  * by the server, so the client signature automatically drops that first parameter.
@@ -71,9 +86,11 @@ function importServer(file) {
                         }
                     }
                 };
+                // Resolve a URL correta (Absoluta no server, Relativa no client)
+                const endpoint = getRpcEndpoint();
                 let res;
                 try {
-                    res = await fetch(types_1.RPC_ENDPOINT, {
+                    res = await fetch(endpoint, {
                         method: 'POST',
                         headers: {
                             'Content-Type': 'application/json'