hightjs 0.1.1

package/src/index.ts

@@ -0,0 +1,514 @@
+import express from 'express';
+import path from 'path';
+import fs from 'fs';
+import { ExpressAdapter } from './adapters/express';
+import { build, watch, buildWithChunks, watchWithChunks } from './builder';
+import { HightJSOptions, RequestHandler, RouteConfig, BackendRouteConfig, BackendHandler, HightMiddleware } from './types';
+import { loadRoutes, findMatchingRoute, loadBackendRoutes, findMatchingBackendRoute, loadLayout, getLayout, loadNotFound, getNotFound } from './router';
+import { render } from './renderer';
+import { HightJSRequest, HightJSResponse } from './api/http';
+import { HotReloadManager } from './hotReload';
+import { FrameworkAdapterFactory } from './adapters/factory';
+import { GenericRequest, GenericResponse } from './types/framework';
+import Console, {Colors} from "./api/console"
+
+// Exporta apenas os tipos e classes para o backend
+export { HightJSRequest, HightJSResponse };
+export type { BackendRouteConfig, BackendHandler };
+
+// Exporta os adapters para uso manual se necessário
+export { ExpressAdapter } from './adapters/express';
+export { FastifyAdapter } from './adapters/fastify';
+export { FrameworkAdapterFactory } from './adapters/factory';
+export type { GenericRequest, GenericResponse, CookieOptions } from './types/framework';
+
+// Exporta os helpers para facilitar integração
+export { app } from './helpers';
+
+// Exporta o sistema de autenticação
+
+// Função para verificar se o projeto é grande o suficiente para se beneficiar de chunks
+function isLargeProject(projectDir: string): boolean {
+    try {
+        const srcDir = path.join(projectDir, 'src');
+        if (!fs.existsSync(srcDir)) return false;
+
+        let totalFiles = 0;
+        let totalSize = 0;
+
+        function scanDirectory(dir: string) {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+
+            for (const item of items) {
+                const fullPath = path.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;
+                }
+            }
+        }
+
+        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: string, routes: (RouteConfig & { componentPath: string })[]): string {
+    const tempDir = path.join(projectDir, '.hweb');
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    const entryFilePath = path.join(tempDir, 'entry.client.js');
+
+    // Verifica se há layout
+    const layout = getLayout();
+
+    // Verifica se há notFound personalizado
+    const notFound = getNotFound();
+
+    // Gera imports dinâmicos para cada componente
+    const imports = routes
+        .map((route, index) => {
+            const relativePath = path.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.relative(tempDir, layout.componentPath).replace(/\\/g, '/')}';`
+        : '';
+
+    // Import do notFound se existir
+    const notFoundImport = notFound
+        ? `import NotFoundComponent from '${path.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.dirname(__dirname); // Vai para a pasta pai de src (onde está o hweb-sdk)
+    const entryClientPath = path.join(sdkDir, 'src', 'client', 'entry.client.tsx');
+    const relativeEntryPath = path.relative(tempDir, entryClientPath).replace(/\\/g, '/');
+
+    // Import do DefaultNotFound do SDK
+    const defaultNotFoundPath = path.join(sdkDir, 'src', 'client', 'DefaultNotFound.tsx');
+    const relativeDefaultNotFoundPath = path.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}';
+`;
+
+    fs.writeFileSync(entryFilePath, entryContent);
+
+    return entryFilePath;
+}
+
+export default function hweb(options: HightJSOptions) {
+    const { dev = true, dir = process.cwd(), port = 3000 } = options;
+    const userWebDir = path.join(dir, 'src', 'web');
+    const userWebRoutesDir = path.join(userWebDir, 'routes');
+    const userBackendRoutesDir = path.join(userWebDir, '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 HightJS
+     * @param params Parâmetros da rota
+     * @returns Resposta do middleware ou handler final
+     */
+    async function executeMiddlewareChain(
+        middlewares: HightMiddleware[] | undefined,
+        finalHandler: BackendHandler,
+        request: HightJSRequest,
+        params: { [key: string]: string }
+    ): Promise<HightJSResponse> {
+        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 (): Promise<HightJSResponse> => {
+            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: (RouteConfig & { componentPath: string })[] = [];
+    let hotReloadManager: HotReloadManager | null = null;
+    let entryPoint: string;
+    let outfile: string;
+
+    // Função para regenerar o entry file
+    const regenerateEntryFile = () => {
+        // Recarrega todas as rotas e componentes
+        frontendRoutes = loadRoutes(userWebRoutesDir);
+        loadLayout(userWebDir);
+        loadNotFound(userWebDir);
+
+        // Regenera o entry file
+        entryPoint = createEntryFile(dir, frontendRoutes);
+    };
+
+    const app = {
+        prepare: async () => {
+            const isProduction = !dev;
+
+            if (!isProduction) {
+                // Inicia hot reload apenas em desenvolvimento (sem logs)
+                hotReloadManager = new HotReloadManager(dir);
+                await hotReloadManager.start();
+
+                // Adiciona callback para recarregar rotas de backend quando mudarem
+                hotReloadManager.onBackendApiChange(() => {
+                    loadBackendRoutes(userBackendRoutesDir);
+                });
+
+                // Adiciona callback para regenerar entry file quando frontend mudar
+                hotReloadManager.onFrontendChange(() => {
+                    regenerateEntryFile();
+                });
+            }
+
+            // ORDEM IMPORTANTE: Carrega TUDO antes de criar o arquivo de entrada
+            frontendRoutes = loadRoutes(userWebRoutesDir);
+            loadBackendRoutes(userBackendRoutesDir);
+
+           // Carrega layout.tsx ANTES de criar o entry file
+            const layout = loadLayout(userWebDir);
+
+           const notFound = loadNotFound(userWebDir);
+
+            const outDir = path.join(dir, 'hweb-dist');
+            fs.mkdirSync(outDir, { recursive: true });
+
+            entryPoint = createEntryFile(dir, frontendRoutes);
+
+            // Usa chunks quando há muitas rotas ou o projeto é grande
+            const shouldUseChunks = frontendRoutes.length > 5 || isLargeProject(dir);
+
+            if (shouldUseChunks) {
+                const outDir = path.join(dir, 'hweb-dist');
+
+                if (isProduction) {
+                    await buildWithChunks(entryPoint, outDir, isProduction);
+                    Console.info(`✅ Build com chunks finalizado! ${frontendRoutes.length} rotas processadas.`);
+                } else {
+                    watchWithChunks(entryPoint, outDir, hotReloadManager!).catch(err => {
+                        Console.error(`Erro ao iniciar o watch com chunks`, err);
+                    });
+                    Console.info(`🚀 Modo watch com chunks ativo para ${frontendRoutes.length} rotas.`);
+                }
+            } else {
+                outfile = path.join(dir, 'hweb-dist', 'main.js');
+
+                if (isProduction) {
+                    await build(entryPoint, outfile, isProduction);
+                } else {
+                    watch(entryPoint, outfile, hotReloadManager!).catch(err => {
+                        Console.error(`Erro ao iniciar o watch`, err);
+                    });
+                }
+            }
+
+        },
+
+        executeInstrumentation: () => {
+
+            // verificar se dir/src/instrumentation.(tsx/jsx/js/ts) existe com regex
+            const instrumentationFile = fs.readdirSync(path.join(dir, 'src')).find(file => /^hightweb\.(tsx|jsx|js|ts)$/.test(file));
+            if (instrumentationFile) {
+                const instrumentationPath = path.join(dir, 'src', instrumentationFile);
+                // dar require, e executar a função principal do arquivo
+                const instrumentation = require(instrumentationPath);
+                if (typeof instrumentation === 'function') {
+                    instrumentation();
+                } else if (typeof instrumentation.default === 'function') {
+                    instrumentation.default();
+                } else {
+                    Console.warn(`O arquivo de instrumentação ${instrumentationFile} não exporta uma função padrão.`);
+                }
+            }
+        },
+        getRequestHandler: (): RequestHandler => {
+            return async (req: any, res: any) => {
+                // Detecta automaticamente o framework e cria o adapter apropriado
+                const adapter = 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 as any).hwebDev = dev;
+                (genericReq as any).hotReloadManager = hotReloadManager;
+
+                const { pathname } = new URL(genericReq.url, `http://${genericReq.headers.host || 'localhost'}`);
+                const method = genericReq.method.toUpperCase();
+
+                // 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('/hweb-')) {
+                    const publicDir = path.join(dir, 'public');
+                    const filePath = path.join(publicDir, pathname);
+
+                    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+                        const ext = path.extname(filePath).toLowerCase();
+                        const contentTypes: Record<string, string> = {
+                            '.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 as any).sendFile(filePath);
+                        } else if (adapter.type === 'fastify') {
+                            const fileContent = fs.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        } else if (adapter.type === 'native') {
+                            const fileContent = fs.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        }
+                        return;
+                    }
+                }
+
+                // 3. Verifica se é um arquivo estático do hweb-dist
+                if (pathname.startsWith('/hweb-dist/')) {
+                    const staticPath = path.join(dir, 'hweb-dist');
+                    const filePath = path.join(staticPath, pathname.replace('/hweb-dist/', ''));
+
+                    if (fs.existsSync(filePath)) {
+                        const ext = path.extname(filePath).toLowerCase();
+                        const contentTypes: Record<string, string> = {
+                            '.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 as any).sendFile(filePath);
+                        } else if (adapter.type === 'fastify') {
+                            const fileContent = fs.readFileSync(filePath);
+                            genericRes.send(fileContent);
+                        } else if (adapter.type === 'native') {
+                            const fileContent = fs.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 = findMatchingBackendRoute(pathname, method);
+                if (backendMatch) {
+                    try {
+                        const handler = backendMatch.route[method as keyof BackendRouteConfig] as BackendHandler;
+                        if (handler) {
+                            const hwebReq = new HightJSRequest(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.error(`Erro na rota de API ${pathname}:`, error);
+                        genericRes.status(500).text('Erro interno do servidor na API');
+                        return;
+                    }
+                }
+
+                // 6. Por último, tenta renderizar uma página (frontend) ou 404
+                const pageMatch = 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 render({
+                            req: genericReq,
+                            route: notFoundRoute,
+                            params: {},
+                            allRoutes: frontendRoutes
+                        });
+                        genericRes.status(404).header('Content-Type', 'text/html').send(html);
+                        return;
+                    } catch (error) {
+                        Console.error(`Erro ao renderizar página 404:`, error);
+                        genericRes.status(404).text('Página não encontrada');
+                        return;
+                    }
+                }
+
+                try {
+                    const html = await render({
+                        req: genericReq,
+                        route: pageMatch.route,
+                        params: pageMatch.params,
+                        allRoutes: frontendRoutes
+                    });
+                    genericRes.status(200).header('Content-Type', 'text/html').send(html);
+                } catch (error) {
+                    Console.error(`Erro ao renderizar a página ${pathname}:`, error);
+                    genericRes.status(500).text('Erro interno do servidor');
+                }
+            };
+        },
+
+        // Método para configurar WebSocket upgrade nos servidores Express e Fastify
+        setupWebSocket: (server: any) => {
+            if (hotReloadManager) {
+                // Detecta se é um servidor Express ou Fastify
+                const isExpressServer = FrameworkAdapterFactory.getCurrentAdapter() instanceof ExpressAdapter;
+
+
+                if (isExpressServer) {
+
+                    server.on('upgrade', (request: any, socket: any, head: Buffer) => {
+                        const { pathname } = new URL(request.url, `http://${request.headers.host}`);
+
+                        if (pathname === '/hweb-hotreload/') {
+                            hotReloadManager!.handleUpgrade(request, socket, head);
+                        } else {
+                            socket.destroy();
+                        }
+                    });
+                } else {
+
+                    // Fastify usa um approach diferente para WebSockets
+                    const actualServer = server.server || server;
+                    actualServer.on('upgrade', (request: any, socket: any, head: Buffer) => {
+                        const { pathname } = new URL(request.url, `http://${request.headers.host}`);
+
+                        if (pathname === '/hweb-hotreload/') {
+                            hotReloadManager!.handleUpgrade(request, socket, head);
+                        } else {
+                            socket.destroy();
+                        }
+                    });
+                }
+            }
+        },
+
+        build: async () => {
+            const msg = Console.dynamicLine(`  ${Colors.FgYellow}●  ${Colors.Reset}Iniciando build do cliente para produção`);
+            const outDir = path.join(dir, 'hweb-dist');
+            fs.mkdirSync(outDir, { recursive: true });
+
+            const routes = loadRoutes(userWebRoutesDir);
+            const entryPoint = createEntryFile(dir, routes);
+            const outfile = path.join(outDir, 'main.js');
+
+            await build(entryPoint, outfile, true); // Força produção no build manual
+
+            msg.end(`  ${Colors.FgGreen}●  ${Colors.Reset}Build do cliente concluído: ${outfile}`);
+        },
+
+        stop: () => {
+            if (hotReloadManager) {
+                hotReloadManager.stop();
+            }
+        }
+    };
+
+    return app;
+}

package/src/renderer.tsx

@@ -0,0 +1,122 @@
+import React from 'react';
+import { RouteConfig, Metadata } from './types';
+import { getLayout } from './router';
+import type { GenericRequest } from './types/framework';
+import fs from 'fs';
+import path from 'path';
+
+// Funções para codificar/decodificar dados (disfarça o JSON no HTML)
+function encodeInitialData(data: any): string {
+    // Converte para JSON, depois para base64, e adiciona um prefixo fake
+    const jsonStr = JSON.stringify(data);
+    const base64 = Buffer.from(jsonStr).toString('base64');
+    return `hweb_${base64}_config`;
+}
+
+function createDecodeScript(): string {
+    return `
+    const process = { env: { NODE_ENV: '${process.env.NODE_ENV || 'development'}' } };
+    window.__HWEB_DECODE__ = function(encoded) { const base64 = encoded.replace('hweb_', '').replace('_config', ''); const jsonStr = atob(base64); return JSON.parse(jsonStr); };
+    `;
+}
+
+// Interface para opções de renderização apenas do cliente
+interface RenderOptions {
+    req: GenericRequest;
+    route: RouteConfig & { componentPath: string };
+    params: Record<string, string>;
+    allRoutes: (RouteConfig & { componentPath: string })[];
+}
+
+export async function render({ req, route, params, allRoutes }: RenderOptions): Promise<string> {
+    const { generateMetadata } = route;
+
+    // Pega a opção dev e hot reload manager do req
+    const isProduction = !(req as any).hwebDev;
+    const hotReloadManager = (req as any).hotReloadManager;
+
+    // Pega o layout se existir
+    const layout = getLayout();
+
+    let metadata: Metadata = { title: 'App hweb' };
+
+    // Primeiro usa o metadata do layout se existir
+    if (layout && layout.metadata) {
+        metadata = { ...metadata, ...layout.metadata };
+    }
+
+    // Depois sobrescreve com metadata específico da rota se existir
+    if (generateMetadata) {
+        const routeMetadata = await Promise.resolve(generateMetadata(params, req));
+        metadata = { ...metadata, ...routeMetadata };
+    }
+
+    // Prepara os dados para injetar na janela do navegador
+    const initialData = {
+        routes: allRoutes.map(r => ({ pattern: r.pattern, componentPath: r.componentPath })),
+        initialComponentPath: route.componentPath,
+        initialParams: params,
+    };
+
+    // Codifica os dados para disfarçar
+    const encodedData = encodeInitialData(initialData);
+
+    // Script de hot reload apenas em desenvolvimento
+    const hotReloadScript = !isProduction && hotReloadManager
+        ? hotReloadManager.getClientScript()
+        : '';
+
+    const favicon = metadata.favicon ? `<link rel="icon" href="${metadata.favicon}">` : '';
+
+    // Determina quais arquivos JavaScript carregar
+    const jsFiles = getJavaScriptFiles(req);
+
+    // HTML base sem SSR - apenas o container e scripts para client-side rendering
+    return `<!DOCTYPE html><html lang="pt-BR"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${metadata.title || 'App hweb'}</title>${metadata.description ? `<meta name="description" content="${metadata.description}">` : ''}${favicon}</head><body><div id="root"></div><script>${createDecodeScript()}window.__HWEB_INITIAL_DATA__ = window.__HWEB_DECODE__('${encodedData}');</script>${jsFiles}${hotReloadScript}</body></html>`;
+}
+
+// Função para determinar quais arquivos JavaScript carregar
+function getJavaScriptFiles(req: GenericRequest): string {
+    const projectDir = process.cwd();
+    const distDir = path.join(projectDir, 'hweb-dist');
+
+    try {
+        // Verifica se existe um manifesto de chunks (gerado pelo ESBuild com splitting)
+        const manifestPath = path.join(distDir, 'manifest.json');
+
+        if (fs.existsSync(manifestPath)) {
+            // Modo chunks - carrega todos os arquivos necessários
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            const scripts = Object.values(manifest)
+                .filter((file: any) => file.endsWith('.js'))
+                .map((file: any) => `<script src="/hweb-dist/${file}"></script>`)
+                .join('');
+            return scripts;
+        } else {
+            // Verifica se existem múltiplos arquivos JS (chunks sem manifesto)
+            const jsFiles = fs.readdirSync(distDir)
+                .filter(file => file.endsWith('.js') && !file.endsWith('.map'))
+                .sort((a, b) => {
+                    // Ordena para carregar arquivos principais primeiro
+                    if (a.includes('main')) return -1;
+                    if (b.includes('main')) return 1;
+                    if (a.includes('vendor') || a.includes('react')) return -1;
+                    if (b.includes('vendor') || b.includes('react')) return 1;
+                    return a.localeCompare(b);
+                });
+
+            if (jsFiles.length > 1) {
+                // Modo chunks sem manifesto
+                return jsFiles
+                    .map(file => `<script src="/hweb-dist/${file}"></script>`)
+                    .join('');
+            } else {
+                // Modo tradicional - único arquivo
+                return '<script src="/hweb-dist/main.js"></script>';
+            }
+        }
+    } catch (error) {
+        // Fallback para o modo tradicional
+        return '<script src="/hweb-dist/main.js"></script>';
+    }
+}