hightjs 0.3.4 → 0.4.0

package/src/hotReload.ts

@@ -195,7 +195,7 @@ export class HotReloadManager {
                                filePath.endsWith('.tsx') ||
                                filePath.endsWith('.jsx');
 
-        const isBackendFile = filePath.includes(path.join('src', 'web', 'backend')) ||
+        const isBackendFile = filePath.includes(path.join('src', 'backend')) ||
                               (filePath.includes(path.join('src', 'web')) && !isFrontendFile);
 
         // Limpa o cache do arquivo alterado
@@ -327,19 +327,21 @@ export class HotReloadManager {
             if (typeof window !== 'undefined') {
                 let ws;
                 let reconnectAttempts = 0;
-                let maxReconnectInterval = 30000; // 30 segundos max
-                let reconnectInterval = 1000; // Começa com 1 segundo
+                let maxReconnectInterval = 30000; 
+                let reconnectInterval = 1000;
                 let reconnectTimer;
                 let isConnected = false;
                 
                 function connect() {
-                    // Evita múltiplas tentativas simultâneas
+                    const url = window.location; // Objeto com info da URL atual
+                    const protocol = url.protocol === "https:" ? "wss:" : "ws:"; // Usa wss se for https
+                    const wsUrl = protocol + '//' + url.host + '/hweb-hotreload/';
                     if (ws && (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN)) {
                         return;
                     }
 
                     try {
-                        ws = new WebSocket('ws://localhost:3000/hweb-hotreload/');
+                        ws = new WebSocket(wsUrl);
                         
                         ws.onopen = function() {
                             console.log('🔌 Hot-reload connected');
@@ -355,10 +357,11 @@ export class HotReloadManager {
                                 
                                 switch(message.type) {
                                     case 'frontend-reload':
-                                        window.location.reload();
+                                        handleFrontendReload(message.data);
                                         break;
                                     case 'backend-api-reload':
-                                        // Recarrega apenas se necessário
+                                        // Backend sempre precisa recarregar
+                                        console.log('🔄 Backend changed, reloading...');
                                         window.location.reload();
                                         break;
                                     case 'server-restart':
@@ -370,12 +373,91 @@ export class HotReloadManager {
                                     case 'frontend-error':
                                         console.error('❌ Frontend error:', message.data);
                                         break;
+                                    case 'hmr-update':
+                                        handleHMRUpdate(message.data);
+                                        break;
                                 }
                             } catch (e) {
                                 console.error('Erro ao processar mensagem do hot-reload:', e);
                             }
                         };
                         
+                        function handleFrontendReload(data) {
+                            if (!data || !data.file) {
+                                window.location.reload();
+                                return;
+                            }
+                            
+                            const file = data.file.toLowerCase();
+                            
+                            // Mudanças que exigem reload completo
+                            const needsFullReload = 
+                                file.includes('layout.tsx') ||
+                                file.includes('layout.jsx') ||
+                                file.includes('not-found.tsx') ||
+                                file.includes('not-found.jsx') ||
+                                file.endsWith('.css');
+                            
+                            if (needsFullReload) {
+                                console.log('⚡ Layout/CSS changed, full reload...');
+                                window.location.reload();
+                                return;
+                            }
+                            
+                            // Mudanças em rotas: tenta HMR
+                            if (file.includes('/routes/') || file.includes('\\\\routes\\\\')) {
+                                console.log('⚡ Route component changed, hot reloading...');
+                                
+                                // Dispara evento para forçar re-render
+                                const event = new CustomEvent('hmr:component-update', { 
+                                    detail: { file: data.file, timestamp: Date.now() } 
+                                });
+                                window.dispatchEvent(event);
+                                
+                                // Aguarda 500ms para ver se o HMR foi bem-sucedido
+                                setTimeout(() => {
+                                    const hmrSuccess = window.__HMR_SUCCESS__;
+                                    if (!hmrSuccess) {
+                                        console.log('⚠️ HMR failed, falling back to full reload');
+                                        window.location.reload();
+                                    } else {
+                                        console.log('✅ HMR successful!');
+                                    }
+                                }, 500);
+                            } else {
+                                // Outros arquivos: reload completo por segurança
+                                window.location.reload();
+                            }
+                        }
+                        
+                        function handleHMRUpdate(data) {
+                            console.log('🔥 HMR Update:', data);
+                            
+                            // Dispara evento customizado para o React capturar
+                            const event = new CustomEvent('hmr:update', { 
+                                detail: data 
+                            });
+                            window.dispatchEvent(event);
+                        }
+                        
+                        function attemptHMR(changedFile) {
+                            // Tenta fazer Hot Module Replacement
+                            // Dispara evento para o React App capturar
+                            const event = new CustomEvent('hmr:component-update', { 
+                                detail: { file: changedFile, timestamp: Date.now() } 
+                            });
+                            window.dispatchEvent(event);
+                            
+                            // Fallback: se após 2s não houve sucesso, reload
+                            setTimeout(() => {
+                                const hmrSuccess = window.__HMR_SUCCESS__;
+                                if (!hmrSuccess) {
+                                    console.log('⚠️ HMR failed, falling back to full reload');
+                                    window.location.reload();
+                                }
+                            }, 2000);
+                        }
+                        
                         ws.onclose = function(event) {
                             isConnected = false;
                             
@@ -476,5 +558,12 @@ export class HotReloadManager {
             this.buildCompleteResolve = null;
         }
         this.isBuilding = false;
+
+        // Notifica os clientes que o build terminou
+        if (success) {
+            this.notifyClients('build-complete', { success: true });
+        } else {
+            this.notifyClients('build-error', { success: false });
+        }
     }
 }

package/src/index.ts

@@ -102,60 +102,61 @@ function isLargeProject(projectDir: string): boolean {
 
 // 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
+    try {
+        const tempDir = path.join(projectDir, '.hight', 'temp');
+
+        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}
@@ -179,9 +180,17 @@ window.__HWEB_DEFAULT_NOT_FOUND__ = DefaultNotFound;
 import '${relativeEntryPath}';
 `;
 
-    fs.writeFileSync(entryFilePath, entryContent);
+        try {
+            fs.writeFileSync(entryFilePath, entryContent);
+        } catch (e) {
+            console.error("sdfijnsdfnijfsdijnfsdnijsdfnijfsdnijfsdnijfsdn", e)
+        }
 
-    return entryFilePath;
+        return entryFilePath;
+    }catch (e){
+        Console.error("Error creating entry file:", e);
+        throw e;
+    }
 }
 
 export default function hweb(options: HightJSOptions) {
@@ -190,7 +199,7 @@ export default function hweb(options: HightJSOptions) {
     process.hight = options;
     const userWebDir = path.join(dir, 'src', 'web');
     const userWebRoutesDir = path.join(userWebDir, 'routes');
-    const userBackendRoutesDir = path.join(userWebDir, 'backend', 'routes');
+    const userBackendRoutesDir = path.join(dir, 'src', 'backend', 'routes');
 
     /**
      * Executa middlewares sequencialmente e depois o handler final
@@ -289,7 +298,7 @@ export default function hweb(options: HightJSOptions) {
 
             const notFound = loadNotFound(userWebDir);
 
-            const outDir = path.join(dir, 'hweb-dist');
+            const outDir = path.join(dir, '.hight');
             fs.mkdirSync(outDir, {recursive: true});
 
             entryPoint = createEntryFile(dir, frontendRoutes);
@@ -317,6 +326,11 @@ export default function hweb(options: HightJSOptions) {
                 time.update(""); // limpa a linha
                 time.end(`  ${Colors.BgGreen} build ${Colors.Reset}    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.dynamicLine(`  ${Colors.BgYellow} watcher ${Colors.Reset}  Starting client watch`);
                 watchWithChunks(entryPoint, outDir, hotReloadManager!).catch(err => {
@@ -373,7 +387,7 @@ export default function hweb(options: HightJSOptions) {
                 }
 
                 // 2. Primeiro verifica se é um arquivo estático da pasta public
-                if (pathname !== '/' && !pathname.startsWith('/api/') && !pathname.startsWith('/hweb-')) {
+                if (pathname !== '/' && !pathname.startsWith('/api/') && !pathname.startsWith('/.hight')) {
                     const publicDir = path.join(dir, 'public');
                     const filePath = path.join(publicDir, pathname);
 
@@ -417,12 +431,14 @@ export default function hweb(options: HightJSOptions) {
                     }
                 }
 
-                // 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/', ''));
+                // 3. Verifica se é um arquivo estático do .hight
+                if (pathname.startsWith('/_hight/')) {
+
+                    const staticPath = path.join(dir, '.hight');
+                    const filePath = path.join(staticPath, pathname.replace('/_hight/', ''));
 
                     if (fs.existsSync(filePath)) {
+
                         const ext = path.extname(filePath).toLowerCase();
                         const contentTypes: Record<string, string> = {
                             '.js': 'application/javascript',

package/src/renderer.tsx

@@ -21,19 +21,128 @@ 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
+// Função para gerar todas as meta tags
+function generateMetaTags(metadata: Metadata): string {
+    const tags: string[] = [];
+
+    // Charset
+    tags.push(`<meta charset="${metadata.charset || 'UTF-8'}">`);
+
+    // Viewport
+    tags.push(`<meta name="viewport" content="${metadata.viewport || 'width=device-width, initial-scale=1.0'}">`);
+
+    // Description
+    if (metadata.description) {
+        tags.push(`<meta name="description" content="${metadata.description}">`);
+    }
+
+    // Keywords
+    if (metadata.keywords) {
+        const keywordsStr = Array.isArray(metadata.keywords)
+            ? metadata.keywords.join(', ')
+            : metadata.keywords;
+        tags.push(`<meta name="keywords" content="${keywordsStr}">`);
+    }
+
+    // Author
+    if (metadata.author) {
+        tags.push(`<meta name="author" content="${metadata.author}">`);
+    }
+
+    // Theme color
+    if (metadata.themeColor) {
+        tags.push(`<meta name="theme-color" content="${metadata.themeColor}">`);
+    }
+
+    // Robots
+    if (metadata.robots) {
+        tags.push(`<meta name="robots" content="${metadata.robots}">`);
+    }
+
+    // Canonical
+    if (metadata.canonical) {
+        tags.push(`<link rel="canonical" href="${metadata.canonical}">`);
+    }
+
+    // Favicon
+    if (metadata.favicon) {
+        tags.push(`<link rel="icon" href="${metadata.favicon}">`);
+    }
+
+    // Apple Touch Icon
+    if (metadata.appleTouchIcon) {
+        tags.push(`<link rel="apple-touch-icon" href="${metadata.appleTouchIcon}">`);
+    }
+
+    // Manifest
+    if (metadata.manifest) {
+        tags.push(`<link rel="manifest" href="${metadata.manifest}">`);
+    }
+
+    // Open Graph
+    if (metadata.openGraph) {
+        const og = metadata.openGraph;
+        if (og.title) tags.push(`<meta property="og:title" content="${og.title}">`);
+        if (og.description) tags.push(`<meta property="og:description" content="${og.description}">`);
+        if (og.type) tags.push(`<meta property="og:type" content="${og.type}">`);
+        if (og.url) tags.push(`<meta property="og:url" content="${og.url}">`);
+        if (og.siteName) tags.push(`<meta property="og:site_name" content="${og.siteName}">`);
+        if (og.locale) tags.push(`<meta property="og:locale" content="${og.locale}">`);
+
+        if (og.image) {
+            if (typeof og.image === 'string') {
+                tags.push(`<meta property="og:image" content="${og.image}">`);
+            } else {
+                tags.push(`<meta property="og:image" content="${og.image.url}">`);
+                if (og.image.width) tags.push(`<meta property="og:image:width" content="${og.image.width}">`);
+                if (og.image.height) tags.push(`<meta property="og:image:height" content="${og.image.height}">`);
+                if (og.image.alt) tags.push(`<meta property="og:image:alt" content="${og.image.alt}">`);
+            }
+        }
+    }
+
+    // Twitter Card
+    if (metadata.twitter) {
+        const tw = metadata.twitter;
+        if (tw.card) tags.push(`<meta name="twitter:card" content="${tw.card}">`);
+        if (tw.site) tags.push(`<meta name="twitter:site" content="${tw.site}">`);
+        if (tw.creator) tags.push(`<meta name="twitter:creator" content="${tw.creator}">`);
+        if (tw.title) tags.push(`<meta name="twitter:title" content="${tw.title}">`);
+        if (tw.description) tags.push(`<meta name="twitter:description" content="${tw.description}">`);
+        if (tw.image) tags.push(`<meta name="twitter:image" content="${tw.image}">`);
+        if (tw.imageAlt) tags.push(`<meta name="twitter:image:alt" content="${tw.imageAlt}">`);
+    }
+
+    // Custom meta tags
+    if (metadata.other) {
+        for (const [key, value] of Object.entries(metadata.other)) {
+            tags.push(`<meta name="${key}" content="${value}">`);
+        }
+    }
+
+    return tags.join('\n');
+}
+
+// Função para ofuscar dados (não é criptografia, apenas ofuscação)
+function obfuscateData(data: any): string {
+    // 1. Serializa para JSON minificado
     const jsonStr = JSON.stringify(data);
+
+    // 2. Converte para base64
     const base64 = Buffer.from(jsonStr).toString('base64');
-    return `hweb_${base64}_config`;
+
+    // 3. Adiciona um hash fake no início para parecer um token
+    const hash = Buffer.from(Date.now().toString()).toString('base64').substring(0, 8);
+
+    return `${hash}.${base64}`;
 }
 
-function createDecodeScript(): string {
-    return `
-    
-    window.__HWEB_DECODE__ = function(encoded) { const base64 = encoded.replace('hweb_', '').replace('_config', ''); const jsonStr = atob(base64); return JSON.parse(jsonStr); };
-    `;
+// Função para criar script ofuscado
+function createInitialDataScript(data: any): string {
+    const obfuscated = obfuscateData(data);
+
+    // Usa um atributo data-* ao invés de JSON visível
+    return `<script id="__hight_data__" type="text/plain" data-h="${obfuscated}"></script>`;
 }
 
 // Interface para opções de renderização apenas do cliente
@@ -74,27 +183,42 @@ export async function render({ req, route, params, allRoutes }: RenderOptions):
         initialParams: params,
     };
 
-    // Codifica os dados para disfarçar
-    const encodedData = encodeInitialData(initialData);
+    // Cria script JSON limpo
+    const initialDataScript = createInitialDataScript(initialData);
 
     // Script de hot reload apenas em desenvolvimento
     const hotReloadScript = !isProduction && hotReloadManager
         ? hotReloadManager.getClientScript()
         : '';
 
-    const favicon = metadata.favicon ? `<link rel="icon" href="${metadata.favicon}">` : '';
+    // Gera todas as meta tags
+    const metaTags = generateMetaTags(metadata);
 
     // Determina quais arquivos JavaScript carregar
     const jsFiles = getJavaScriptFiles(req);
 
+    const htmlLang = metadata.language || 'pt-BR';
+
     // 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>`;
+    return `<!DOCTYPE html>
+<html lang="${htmlLang}">
+<head>
+${metaTags}
+<title>${metadata.title || 'App hweb'}</title>
+</head>
+<body>
+<div id="root"></div>
+${initialDataScript}
+${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');
+    const distDir = path.join(projectDir, '.hight');
 
     try {
         // Verifica se existe um manifesto de chunks (gerado pelo ESBuild com splitting)
@@ -105,7 +229,7 @@ function getJavaScriptFiles(req: GenericRequest): string {
             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>`)
+                .map((file: any) => `<script src="/_hight/${file}"></script>`)
                 .join('');
             return scripts;
         } else {
@@ -125,15 +249,15 @@ function getJavaScriptFiles(req: GenericRequest): string {
             if (jsFiles.length >= 1) {
                 // Modo chunks sem manifesto
                 return jsFiles
-                    .map(file => `<script src="/hweb-dist/${file}"></script>`)
+                    .map(file => `<script src="/_hight/${file}"></script>`)
                     .join('');
             } else {
                 // Modo tradicional - único arquivo
-                return '<script src="/hweb-dist/main.js"></script>';
+                return '<script src="/_hight/main.js"></script>';
             }
         }
     } catch (error) {
         // Fallback para o modo tradicional
-        return '<script src="/hweb-dist/main.js"></script>';
+        return '<script src="/_hight/main.js"></script>';
     }
 }

package/src/router.ts

@@ -671,6 +671,7 @@ export function setupWebSocketUpgrade(server: any, hotReloadManager?: any) {
     // Se não há listeners, ou se o hot-reload ainda não foi configurado, adiciona o nosso
     if (existingListeners.length === 0) {
         server.on('upgrade', (request: any, socket: any, head: Buffer) => {
+
             handleWebSocketUpgrade(request, socket, head, hotReloadManager);
         });
     }
@@ -689,6 +690,7 @@ function handleWebSocketUpgrade(request: any, socket: any, head: Buffer, hotRelo
 
     // Prioridade 1: Hot reload (sistema interno)
     if (pathname === '/hweb-hotreload/') {
+
         if (hotReloadManager) {
             hotReloadManager.handleUpgrade(request, socket, head);
         } else {

package/src/types.ts

@@ -90,6 +90,12 @@ export interface HightConfig {
      * Padrão: 2048
      */
     maxUrlLength?: number;
+
+    /**
+     * Habilita o log de acesso HTTP (ex: GET /api/users 200 15ms).
+     * Padrão: false
+     */
+    accessLogging?: boolean;
 }
 
 /**
@@ -99,11 +105,61 @@ export type HightConfigFunction = (
     phase: string,
     context: { defaultConfig: HightConfig }
 ) => HightConfig | Promise<HightConfig>;
+
 export interface Metadata {
+    // Basic metadata
     title?: string;
     description?: string;
+    keywords?: string | string[];
+    author?: string;
     favicon?: string;
+
+    // Viewport and mobile
+    viewport?: string;
+    themeColor?: string;
+
+    // SEO
+    canonical?: string;
+    robots?: string;
+
+    // Open Graph (Facebook, LinkedIn, etc.)
+    openGraph?: {
+        title?: string;
+        description?: string;
+        type?: string;
+        url?: string;
+        image?: string | {
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+        };
+        siteName?: string;
+        locale?: string;
+    };
+
+    // Twitter Card
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        imageAlt?: string;
+    };
+
+    // Additional metadata
+    language?: string;
+    charset?: string;
+    appleTouchIcon?: string;
+    manifest?: string;
+
+    // Custom meta tags
+    other?: Record<string, string>;
 }
+
+
 export interface RouteConfig {
     pattern: string;
     component: ComponentType<any>;

package/example/src/web/backend/routes/auth.ts

@@ -1,3 +0,0 @@
-import {authRoutes} from "../../../auth";
-
-export default authRoutes