olova 2.0.39 → 2.0.41

package/dist/vite.js

@@ -1,1828 +0,0 @@
-// src/plugins/config.ts
-import fs from "fs";
-import path from "path";
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  cyan: "\x1B[36m",
-  green: "\x1B[32m",
-  white: "\x1B[37m"
-};
-function configPlugin() {
-  const olovaDir = path.resolve(".olova");
-  return {
-    name: "olova-config",
-    config(_config, { command }) {
-      if (!fs.existsSync(olovaDir)) {
-        fs.mkdirSync(olovaDir, { recursive: true });
-      }
-      if (process.env.IS_SSG_BUILD) {
-        return {
-          appType: "custom",
-          cacheDir: "./.olova/cache"
-        };
-      }
-      if (command === "serve") {
-        console.log("");
-        console.log(`  ${colors.bold}${colors.cyan}\u{1F7E2} Olova${colors.reset} ${colors.dim}v1.0.0${colors.reset}`);
-        console.log("");
-      }
-      return {
-        appType: "custom",
-        cacheDir: "./.olova/cache",
-        build: {
-          outDir: "./.olova/dist",
-          sourcemap: false,
-          chunkSizeWarningLimit: 500,
-          rollupOptions: {
-            onwarn(warning, warn) {
-              if (warning.code === "PLUGIN_WARNING" && warning.message?.includes("dynamic import will not move")) {
-                return;
-              }
-              if (warning.message?.includes("Module level directives") && warning.message?.includes("static")) {
-                return;
-              }
-              if (warning.message?.includes("sourcemap") && warning.message?.includes("Can't resolve original location")) {
-                return;
-              }
-              warn(warning);
-            },
-            output: {
-              chunkFileNames: "pro_olova_static/chunks/[name]-[hash].js",
-              entryFileNames: "pro_olova_static/olova-[hash].js",
-              assetFileNames: "pro_olova_static/[name]-[hash][extname]",
-              manualChunks(id) {
-                if (id.includes("node_modules")) {
-                  if (id.includes("react-dom")) {
-                    return "vendor-react-dom";
-                  }
-                  if (id.includes("react")) {
-                    return "vendor-react";
-                  }
-                  if (id.includes("olova")) {
-                    return void 0;
-                  }
-                  return "vendor";
-                }
-              }
-            }
-          }
-        },
-        preview: {
-          port: 4173,
-          strictPort: false
-        },
-        // Exclude olova from dependency optimization so our virtual modules work
-        optimizeDeps: {
-          exclude: ["olova", "olova/router"]
-        },
-        // Also configure SSR to handle these modules
-        ssr: {
-          noExternal: ["olova", /^virtual:/]
-        }
-      };
-    },
-    configureServer(server) {
-      server.httpServer?.once("listening", () => {
-        const address = server.httpServer?.address();
-        const port = typeof address === "object" && address ? address.port : 5173;
-        setTimeout(() => {
-          console.log(`  ${colors.green}\u2713${colors.reset} Ready in ${colors.dim}${Math.round(performance.now())}ms${colors.reset}`);
-          console.log("");
-          console.log(`  ${colors.dim}\u279C${colors.reset}  ${colors.bold}Local:${colors.reset}   ${colors.cyan}http://localhost:${port}/${colors.reset}`);
-          console.log("");
-        }, 100);
-      });
-    }
-  };
-}
-
-// src/plugins/router.ts
-import fs2 from "fs";
-import path2 from "path";
-function routerPlugin() {
-  const virtualModuleId = "virtual:olova-routes";
-  const resolvedVirtualModuleId = "\0" + virtualModuleId;
-  let server = null;
-  const invalidateRoutes = () => {
-    if (server) {
-      const mod = server.moduleGraph.getModuleById(resolvedVirtualModuleId);
-      if (mod) {
-        server.moduleGraph.invalidateModule(mod);
-        server.ws.send({
-          type: "full-reload",
-          path: "*"
-        });
-      }
-    }
-  };
-  return {
-    name: "olova-router",
-    enforce: "pre",
-    // Configure dev server to watch for file changes
-    configureServer(devServer) {
-      server = devServer;
-      const srcDir = path2.resolve(process.cwd(), "src");
-      const watcher = devServer.watcher;
-      watcher.on("add", (filePath) => {
-        if (filePath.startsWith(srcDir) && /\.(tsx|jsx|html|md)$/.test(filePath)) {
-          console.log("\x1B[36m[olova]\x1B[0m New route detected:", path2.relative(srcDir, filePath));
-          invalidateRoutes();
-        }
-      });
-      watcher.on("unlink", (filePath) => {
-        if (filePath.startsWith(srcDir) && /\.(tsx|jsx|html|md)$/.test(filePath)) {
-          console.log("\x1B[36m[olova]\x1B[0m Route removed:", path2.relative(srcDir, filePath));
-          invalidateRoutes();
-        }
-      });
-      watcher.on("addDir", (dirPath) => {
-        if (dirPath.startsWith(srcDir) && dirPath !== srcDir) {
-          console.log("\x1B[36m[olova]\x1B[0m New route folder detected:", path2.relative(srcDir, dirPath));
-        }
-      });
-      watcher.on("unlinkDir", (dirPath) => {
-        if (dirPath.startsWith(srcDir) && dirPath !== srcDir) {
-          console.log("\x1B[36m[olova]\x1B[0m Route folder removed:", path2.relative(srcDir, dirPath));
-          invalidateRoutes();
-        }
-      });
-    },
-    resolveId(id) {
-      if (id === virtualModuleId) {
-        return resolvedVirtualModuleId;
-      }
-    },
-    // Mark the virtual module as having side effects for proper HMR
-    handleHotUpdate({ file, server: devServer }) {
-      const srcDir = path2.resolve(process.cwd(), "src");
-      if (file.startsWith(srcDir) && /\.(tsx|jsx)$/.test(file)) {
-        const mod = devServer.moduleGraph.getModuleById(resolvedVirtualModuleId);
-        if (mod) {
-          devServer.moduleGraph.invalidateModule(mod);
-        }
-      }
-    },
-    load(id) {
-      if (id === resolvedVirtualModuleId) {
-        const srcDir = path2.resolve(process.cwd(), "src");
-        const getRoutes = (dir, baseRoute = "", baseImportPath = "") => {
-          const entries = fs2.readdirSync(dir, { withFileTypes: true });
-          let routes = [];
-          for (const entry of entries) {
-            const entryName = entry.name;
-            const fullPath = path2.join(dir, entryName);
-            if (entry.isDirectory()) {
-              const isRouteGroup = /^\(.+\)$/.test(entryName);
-              if (isRouteGroup) {
-                routes = routes.concat(getRoutes(
-                  fullPath,
-                  baseRoute,
-                  // URL path stays the same (group is ignored)
-                  `${baseImportPath}/${entryName}`
-                  // Import path includes the folder
-                ));
-              } else {
-                routes = routes.concat(getRoutes(
-                  fullPath,
-                  `${baseRoute}/${entryName}`,
-                  `${baseImportPath}/${entryName}`
-                ));
-              }
-            } else {
-              const ext = path2.extname(entryName);
-              const supportedExts = [".tsx", ".jsx", ".html", ".md"];
-              if (supportedExts.includes(ext)) {
-                const nameNoExt = entryName.replace(/\.(tsx|jsx|html|md)$/, "");
-                if (nameNoExt === "root") continue;
-                let routePath = baseRoute;
-                if (nameNoExt !== "index" && nameNoExt !== "App") {
-                  routePath = `${baseRoute}/${nameNoExt}`;
-                }
-                if (routePath === "") routePath = "/";
-                const normalizedRoutePath = routePath.replace(/\$(.+?)(?=\/|$)/g, ":$1");
-                const importPath = `/src${baseImportPath}/${entryName}`;
-                if (ext === ".html") {
-                  routes.push(`  "${normalizedRoutePath}": () => import("${importPath}?raw").then(m => ({ default: () => { const div = document.createElement('div'); div.innerHTML = m.default; return div.innerHTML; }, __isHtml: true, __isStatic: true, __rawHtml: m.default })),`);
-                } else if (ext === ".md") {
-                  routes.push(`  "${normalizedRoutePath}": () => import("${importPath}?raw").then(m => ({ default: m.default, __isMd: true, __isStatic: true })),`);
-                } else {
-                  const fileContent = fs2.readFileSync(fullPath, "utf-8");
-                  const firstLine = fileContent.trim().split("\n")[0].trim();
-                  const hasStaticDirective = firstLine === '"static"' || firstLine === "'static'";
-                  if (hasStaticDirective) {
-                    routes.push(`  "${normalizedRoutePath}": () => import("${importPath}").then(m => Object.assign({}, m, { __isStatic: true })),`);
-                  } else {
-                    routes.push(`  "${normalizedRoutePath}": () => import("${importPath}"),`);
-                  }
-                }
-              }
-            }
-          }
-          return routes;
-        };
-        let routeLines = [];
-        if (fs2.existsSync(srcDir)) {
-          routeLines = getRoutes(srcDir);
-        }
-        return `export const routes = {
-${routeLines.join("\n")}
-};`;
-      }
-    }
-  };
-}
-
-// src/plugins/framework.ts
-import { transformWithEsbuild } from "vite";
-function frameworkPlugin() {
-  const virtualClientEntry = "olova/client";
-  const resolvedVirtualClientEntry = "\0" + virtualClientEntry;
-  const virtualServerEntry = "olova/server";
-  const resolvedVirtualServerEntry = "\0" + virtualServerEntry;
-  return {
-    name: "olova-framework",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === virtualClientEntry || id === "/olova/client" || id === "olova/client.tsx") return resolvedVirtualClientEntry;
-      if (id === virtualServerEntry || id === "/olova/server" || id === "olova/server.tsx") return resolvedVirtualServerEntry;
-    },
-    async load(id) {
-      if (id === resolvedVirtualClientEntry) {
-        const code = `
-import React from 'react';
-import { hydrateRoot, createRoot } from 'react-dom/client';
-import Layout, { metadata as defaultMetadata } from '/src/root.tsx';
-import { Router, loadRoute } from 'olova/router';
-
-// Helper to generate SEO meta tags
-function generateSeoTags(metadata) {
-  const meta = { ...defaultMetadata, ...metadata };
-  const tags = [];
-  
-  // Title
-  if (meta.title) {
-    document.title = meta.title;
-  }
-  
-  // Description
-  if (meta.description) {
-    let tag = document.querySelector('meta[name="description"]');
-    if (!tag) {
-      tag = document.createElement('meta');
-      tag.setAttribute('name', 'description');
-      document.head.appendChild(tag);
-    }
-    tag.setAttribute('content', meta.description);
-  }
-  
-  // Keywords
-  if (meta.keywords) {
-    const content = Array.isArray(meta.keywords) ? meta.keywords.join(', ') : meta.keywords;
-    let tag = document.querySelector('meta[name="keywords"]');
-    if (!tag) {
-      tag = document.createElement('meta');
-      tag.setAttribute('name', 'keywords');
-      document.head.appendChild(tag);
-    }
-    tag.setAttribute('content', content);
-  }
-  
-  // Open Graph
-  if (meta.openGraph) {
-    const og = meta.openGraph;
-    const ogTags = [
-      ['og:title', og.title || meta.title],
-      ['og:description', og.description],
-      ['og:url', og.url],
-      ['og:site_name', og.siteName],
-      ['og:type', og.type],
-    ];
-    ogTags.forEach(([prop, content]) => {
-      if (content) {
-        let tag = document.querySelector(\`meta[property="\${prop}"]\`);
-        if (!tag) {
-          tag = document.createElement('meta');
-          tag.setAttribute('property', prop);
-          document.head.appendChild(tag);
-        }
-        tag.setAttribute('content', content);
-      }
-    });
-  }
-  
-  // Twitter Card
-  if (meta.twitter) {
-    const tw = meta.twitter;
-    const twTags = [
-      ['twitter:card', tw.card || 'summary'],
-      ['twitter:site', tw.site],
-      ['twitter:creator', tw.creator],
-      ['twitter:title', tw.title || meta.title],
-      ['twitter:description', tw.description],
-    ];
-    twTags.forEach(([name, content]) => {
-      if (content) {
-        let tag = document.querySelector(\`meta[name="\${name}"]\`);
-        if (!tag) {
-          tag = document.createElement('meta');
-          tag.setAttribute('name', name);
-          document.head.appendChild(tag);
-        }
-        tag.setAttribute('content', content);
-      }
-    });
-  }
-}
-
-const path = window.location.pathname;
-loadRoute(path).then((result) => {
-  const Component = result ? result.module.default : () => <div>404 Not Found</div>;
-  // @ts-ignore
-  const serverData = window.__OLOVA_DATA__ || window.$OLOVA?.$route || {};
-  const params = serverData.params || (result ? result.params : {});
-  const metadata = serverData.metadata || (result ? result.metadata : undefined);
-
-  // Framework handles SEO automatically (like Next.js)
-  generateSeoTags(metadata);
-
-  const app = (
-    <React.StrictMode>
-       <Layout>
-         <Router url={path} initialComponent={Component} initialParams={params} onRouteChange={(newMetadata) => generateSeoTags(newMetadata)} />
-       </Layout>
-    </React.StrictMode>
-  );
-
-  // Always hydrate using the document as root since we always have a shell from SSG
-  console.log("[Olova] Hydrating document with component:", Component ? (Component.name || 'Anonymous') : "NULL");
-  
-  // Debug loaded route result
-  if (result) {
-    console.log("[Olova] Route module keys:", Object.keys(result.module));
-  } else {
-    console.warn("[Olova] Route result is null/undefined");
-  }
-
-  hydrateRoot(document, app);
-});`;
-        const result = await transformWithEsbuild(code, "olova-client.tsx", {
-          loader: "tsx",
-          jsx: "automatic"
-        });
-        return result.code;
-      }
-      if (id === resolvedVirtualServerEntry) {
-        const code = `
-import React from 'react';
-import { renderToString } from 'react-dom/server';
-import Layout, { metadata as defaultMetadata } from '/src/root.tsx';
-import { routes } from 'virtual:olova-routes';
-
-// =============================================================================
-// INLINE ROUTER UTILITIES (to avoid external olova/router import)
-// =============================================================================
-const normalizePath = (path) => {
-  let p = path.split('?')[0].split('#')[0];
-  if (p.length > 1 && p.endsWith('/')) p = p.slice(0, -1);
-  return p || '/';
-};
-
-function matchRoute(path) {
-  const normalizedPath = normalizePath(path);
-  const routeKeys = Object.keys(routes);
-  
-  for (const route of routeKeys) {
-    if (route === normalizedPath) {
-      return { loader: routes[route], params: {}, pattern: route };
-    }
-    
-    const regexPath = route
-      .replace(/:[^\\/]+/g, '([^/]+)')
-      .replace(/\\$[^\\/]+/g, '([^/]+)');
-    
-    const regex = new RegExp(\`^\${regexPath}$\`);
-    const match = normalizedPath.match(regex);
-    
-    if (match) {
-      const params = {};
-      const paramNames = (route.match(/[:\\$][^\\/]+/g) || []).map(s => s.slice(1));
-      paramNames.forEach((name, i) => {
-        params[name] = match[i + 1];
-      });
-      return { loader: routes[route], params, pattern: route };
-    }
-  }
-  return null;
-}
-
-function parseMarkdown(md) {
-  return md
-    .replace(/^### (.*$)/gim, '<h3>$1</h3>')
-    .replace(/^## (.*$)/gim, '<h2>$1</h2>')
-    .replace(/^# (.*$)/gim, '<h1>$1</h1>')
-    .replace(/\\*\\*\\*(.*?)\\*\\*\\*/g, '<strong><em>$1</em></strong>')
-    .replace(/\\*\\*(.*?)\\*\\*/g, '<strong>$1</strong>')
-    .replace(/\\*(.*?)\\*/g, '<em>$1</em>')
-    .replace(/\`\`\`([\\s\\S]*?)\`\`\`/g, '<pre><code>$1</code></pre>')
-    .replace(/\`(.*?)\`/g, '<code>$1</code>')
-    .replace(/\\[([^\\]]+)\\]\\(([^)]+)\\)/g, '<a href="$2">$1</a>')
-    .replace(/\\n\\n/g, '</p><p>')
-    .replace(/\\n/g, '<br>')
-    .replace(/^(.*)$/, '<p>$1</p>');
-}
-
-function HtmlContent({ html }) {
-  return React.createElement('div', { 
-    dangerouslySetInnerHTML: { __html: html },
-    className: 'olova-html-content'
-  });
-}
-
-function MarkdownContent({ markdown }) {
-  const html = parseMarkdown(markdown);
-  return React.createElement('article', { 
-    dangerouslySetInnerHTML: { __html: html },
-    className: 'olova-markdown-content'
-  });
-}
-
-async function loadRoute(path) {
-  const match = matchRoute(path);
-  if (match) {
-    const module = await match.loader();
-    
-    if (module.__isHtml) {
-      return { 
-        module: {
-          default: () => HtmlContent({ html: module.__rawHtml }),
-        },
-        params: match.params,
-        metadata: undefined
-      };
-    }
-    
-    if (module.__isMd) {
-      return { 
-        module: {
-          default: () => MarkdownContent({ markdown: module.default }),
-        },
-        params: match.params,
-        metadata: undefined
-      };
-    }
-    
-    return { 
-      module,
-      params: match.params,
-      metadata: module.metadata
-    };
-  }
-  return null;
-}
-
-const RouterContext = React.createContext({ params: {}, path: '/' });
-
-function Router({ url, initialComponent, initialParams }) {
-  const Component = initialComponent || (() => <div>Loading...</div>);
-  const params = initialParams || {};
-  // Server-side: Just render the Component directly (no Context needed)
-  // The Context.Provider wrapping happens on client for hooks to work
-  return <Component {...params} />;
-}
-
-// =============================================================================
-// SEO HEAD GENERATION
-// =============================================================================
-function generateSeoHead(metadata) {
-  const meta = { ...defaultMetadata, ...metadata };
-  let head = '';
-  
-  if (meta.title) {
-    head += \`<title>\${meta.title}</title>\\n\`;
-  }
-  
-  if (meta.description) {
-    head += \`<meta name="description" content="\${meta.description}" />\\n\`;
-  }
-  if (meta.keywords) {
-    const content = Array.isArray(meta.keywords) ? meta.keywords.join(', ') : meta.keywords;
-    head += \`<meta name="keywords" content="\${content}" />\\n\`;
-  }
-  if (meta.robots) {
-    head += \`<meta name="robots" content="\${meta.robots}" />\\n\`;
-  }
-  if (meta.canonical) {
-    head += \`<link rel="canonical" href="\${meta.canonical}" />\\n\`;
-  }
-  
-  if (meta.openGraph) {
-    const og = meta.openGraph;
-    head += \`<meta property="og:title" content="\${og.title || meta.title}" />\\n\`;
-    if (og.description) head += \`<meta property="og:description" content="\${og.description}" />\\n\`;
-    if (og.url) head += \`<meta property="og:url" content="\${og.url}" />\\n\`;
-    if (og.siteName) head += \`<meta property="og:site_name" content="\${og.siteName}" />\\n\`;
-    if (og.type) head += \`<meta property="og:type" content="\${og.type}" />\\n\`;
-    if (og.images) {
-      og.images.forEach(img => {
-        head += \`<meta property="og:image" content="\${img.url}" />\\n\`;
-      });
-    }
-  }
-  
-  if (meta.twitter) {
-    const tw = meta.twitter;
-    head += \`<meta name="twitter:card" content="\${tw.card || 'summary'}" />\\n\`;
-    if (tw.site) head += \`<meta name="twitter:site" content="\${tw.site}" />\\n\`;
-    if (tw.creator) head += \`<meta name="twitter:creator" content="\${tw.creator}" />\\n\`;
-    head += \`<meta name="twitter:title" content="\${tw.title || meta.title}" />\\n\`;
-    if (tw.description) head += \`<meta name="twitter:description" content="\${tw.description}" />\\n\`;
-    if (tw.images) {
-      tw.images.forEach(img => {
-        head += \`<meta name="twitter:image" content="\${img}" />\\n\`;
-      });
-    }
-  }
-  
-  return head;
-}
-
-// =============================================================================
-// SERVER RENDER FUNCTIONS
-// =============================================================================
-export async function render(url) {
-  const result = await loadRoute(url);
-  const Component = result ? result.module.default : () => <div>404 Not Found</div>;
-  const params = result ? result.params : {};
-  const metadata = result ? result.metadata : undefined;
-  
-  const seoHead = generateSeoHead(metadata);
-  
-  let html = renderToString(
-    <Layout>
-      <Router url={url} initialComponent={Component} initialParams={params} />
-    </Layout>
-  );
-  
-  if (html.includes('</head>')) {
-    html = html.replace('</head>', seoHead + '</head>');
-  }
-  
-  return { html, hydrationData: { params, metadata } };
-}
-
-export function renderShell() {
-  const seoHead = generateSeoHead({});
-  let html = renderToString(<Layout>{null}</Layout>);
-  if (html.includes('</head>')) {
-    html = html.replace('</head>', seoHead + '</head>');
-  }
-  return html;
-}
-
-export function renderShellWithMetadata(metadata) {
-  const seoHead = generateSeoHead(metadata);
-  let html = renderToString(<Layout>{null}</Layout>);
-  if (html.includes('</head>')) {
-    html = html.replace('</head>', seoHead + '</head>');
-  }
-  return html;
-}
-
-export { loadRoute };`;
-        const result = await transformWithEsbuild(code, "olova-server.tsx", {
-          loader: "tsx",
-          jsx: "automatic"
-        });
-        return result.code;
-      }
-    }
-  };
-}
-
-// src/plugins/virtual-html.ts
-import fs3 from "fs";
-import path3 from "path";
-
-// src/plugins/hydration.ts
-function generateOlovaHydration(data, buildId) {
-  const meta = data.metadata || {};
-  const scripts = [];
-  scripts.push(`<script>self.__olova_f=self.__olova_f||[];function _oF(d){self.__olova_f.push(d)}</script>`);
-  const routeChunk = {
-    type: "R",
-    data: {
-      path: data.route,
-      params: data.params || {},
-      pattern: data.route === "/" ? "/" : data.route.replace(/\/[^/]+$/, "/:slug"),
-      isStatic: data.isStatic ?? true,
-      buildId
-    }
-  };
-  scripts.push(`<script>_oF([0,"${routeChunk.type}",${JSON.stringify(routeChunk.data)}])</script>`);
-  const metadataChunk = {
-    type: "M",
-    data: {
-      title: meta.title || "Olova App",
-      description: meta.description || "",
-      keywords: Array.isArray(meta.keywords) ? meta.keywords : [],
-      robots: meta.robots || "index, follow",
-      canonical: meta.canonical || null,
-      og: {
-        type: "website",
-        locale: "en_US",
-        ...meta.openGraph || {}
-      },
-      twitter: {
-        card: "summary_large_image",
-        ...meta.twitter || {}
-      }
-    }
-  };
-  scripts.push(`<script>_oF([1,"${metadataChunk.type}",${JSON.stringify(metadataChunk.data)}])</script>`);
-  const pageName = data.route === "/" ? "HomePage" : data.route.slice(1).split("/").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Page";
-  const treeChunk = {
-    type: "T",
-    data: {
-      layout: "RootLayout",
-      page: pageName,
-      template: null,
-      loading: null,
-      error: null,
-      notFound: null
-    }
-  };
-  scripts.push(`<script>_oF([2,"${treeChunk.type}",${JSON.stringify(treeChunk.data)}])</script>`);
-  const structuredData = {
-    type: "D",
-    data: [
-      {
-        "@context": "https://schema.org",
-        "@type": "WebPage",
-        name: meta.title || "Olova App",
-        description: meta.description || "",
-        url: data.route
-      },
-      {
-        "@context": "https://schema.org",
-        "@type": "WebApplication",
-        name: "Olova",
-        applicationCategory: "WebApplication",
-        operatingSystem: "Any"
-      }
-    ]
-  };
-  scripts.push(`<script>_oF([3,"${structuredData.type}",${JSON.stringify(structuredData.data)}])</script>`);
-  const assetsChunk = {
-    type: "A",
-    data: {
-      chunks: data.chunks || [],
-      styles: [],
-      // Prefetch hints for next likely navigations
-      prefetch: (data.chunks || []).slice(0, 5)
-    }
-  };
-  scripts.push(`<script>_oF([4,"${assetsChunk.type}",${JSON.stringify(assetsChunk.data)}])</script>`);
-  const hintsChunk = {
-    type: "H",
-    data: {
-      dnsPrefetch: ["fonts.googleapis.com", "fonts.gstatic.com"],
-      preconnect: ["https://fonts.googleapis.com", "https://fonts.gstatic.com"],
-      modulePreload: (data.chunks || []).slice(0, 3)
-    }
-  };
-  scripts.push(`<script>_oF([5,"${hintsChunk.type}",${JSON.stringify(hintsChunk.data)}])</script>`);
-  const stateChunk = {
-    type: "S",
-    data: {
-      hydrated: false,
-      streaming: false,
-      ready: true,
-      timestamp: Date.now(),
-      version: "1.0.0",
-      buildId
-    }
-  };
-  scripts.push(`<script>_oF([6,"${stateChunk.type}",${JSON.stringify(stateChunk.data)}])</script>`);
-  scripts.push(`<script>_oF([7,"E",null])</script>`);
-  const globalPayload = {
-    $route: routeChunk.data,
-    $meta: metadataChunk.data,
-    $tree: treeChunk.data,
-    $schema: structuredData.data,
-    $assets: assetsChunk.data,
-    $hints: hintsChunk.data,
-    $state: stateChunk.data,
-    $build: {
-      id: buildId,
-      version: "1.0.0",
-      timestamp: Date.now(),
-      env: "production"
-    }
-  };
-  scripts.push(`<script>$OLOVA=${JSON.stringify(globalPayload)}</script>`);
-  return scripts.join("");
-}
-function generateJsonLd(data) {
-  const meta = data.metadata || {};
-  const jsonLd = {
-    "@context": "https://schema.org",
-    "@graph": [
-      {
-        "@type": "WebPage",
-        "@id": data.route,
-        name: meta.title || "Olova App",
-        description: meta.description || "",
-        url: data.route,
-        isPartOf: {
-          "@type": "WebSite",
-          name: "Olova App"
-        }
-      },
-      {
-        "@type": "BreadcrumbList",
-        itemListElement: data.route.split("/").filter(Boolean).map((segment, index, arr) => ({
-          "@type": "ListItem",
-          position: index + 1,
-          name: segment.charAt(0).toUpperCase() + segment.slice(1),
-          item: "/" + arr.slice(0, index + 1).join("/")
-        }))
-      }
-    ]
-  };
-  return `<script type="application/ld+json">${JSON.stringify(jsonLd)}</script>`;
-}
-function parseFlightData() {
-  if (typeof globalThis === "undefined" || typeof globalThis.document === "undefined") {
-    return null;
-  }
-  const flightArray = globalThis.__olova_f;
-  if (!flightArray) return null;
-  const result = {};
-  const typeMap = {
-    "M": "$meta",
-    "T": "$tree",
-    "R": "$route",
-    "P": "$params",
-    "A": "$assets",
-    "S": "$state",
-    "D": "$schema",
-    "H": "$hints",
-    "E": "$end"
-  };
-  for (const chunk of flightArray) {
-    if (Array.isArray(chunk) && chunk.length >= 3) {
-      const [_index, type, data] = chunk;
-      const key = typeMap[type];
-      if (key && key !== "$end") {
-        result[key] = data;
-      }
-    }
-  }
-  return result;
-}
-
-// src/plugins/virtual-html.ts
-function virtualHtmlPlugin() {
-  let viteServer = null;
-  const isStaticRoute = (routePath) => {
-    const srcDir = path3.resolve("src");
-    let filePath = routePath === "/" ? "" : routePath.slice(1);
-    const htmlMdPaths = [
-      path3.join(srcDir, filePath, "index.html"),
-      path3.join(srcDir, filePath, "index.md"),
-      path3.join(srcDir, filePath + ".html"),
-      path3.join(srcDir, filePath + ".md")
-    ];
-    for (const p of htmlMdPaths) {
-      if (fs3.existsSync(p)) {
-        const ext = path3.extname(p).slice(1);
-        return { isStatic: true, fileType: ext };
-      }
-    }
-    const tsxJsxPaths = [
-      path3.join(srcDir, filePath, "index.tsx"),
-      path3.join(srcDir, filePath, "index.jsx"),
-      path3.join(srcDir, filePath + ".tsx"),
-      path3.join(srcDir, filePath + ".jsx"),
-      path3.join(srcDir, "App.tsx"),
-      path3.join(srcDir, "App.jsx")
-    ];
-    for (const p of tsxJsxPaths) {
-      if (fs3.existsSync(p)) {
-        const content = fs3.readFileSync(p, "utf-8");
-        const firstLine = content.trim().split("\n")[0].trim();
-        const isStatic = firstLine === '"static"' || firstLine === "'static'";
-        const ext = path3.extname(p).slice(1);
-        return { isStatic, fileType: ext };
-      }
-    }
-    return { isStatic: false, fileType: null };
-  };
-  const extractMetadata = (filePath) => {
-    try {
-      if (!fs3.existsSync(filePath)) return {};
-      const content = fs3.readFileSync(filePath, "utf-8");
-      const metadataMatch = content.match(/export\s+const\s+metadata\s*=\s*(\{[\s\S]*?\});/);
-      if (metadataMatch) {
-        try {
-          let metaStr = metadataMatch[1].replace(/'/g, '"').replace(/(\w+):/g, '"$1":').replace(/,\s*}/g, "}").replace(/,\s*]/g, "]");
-          return JSON.parse(metaStr);
-        } catch {
-          const titleMatch = content.match(/title:\s*['"]([^'"]+)['"]/);
-          const descMatch = content.match(/description:\s*['"]([^'"]+)['"]/);
-          return {
-            title: titleMatch?.[1] || "Olova App",
-            description: descMatch?.[1] || ""
-          };
-        }
-      }
-      return {};
-    } catch {
-      return {};
-    }
-  };
-  const getRouteMetadata = (routePath) => {
-    const srcDir = path3.resolve("src");
-    let filePath = routePath === "/" ? "" : routePath.slice(1);
-    const possiblePaths = [
-      path3.join(srcDir, filePath, "index.tsx"),
-      path3.join(srcDir, filePath, "index.jsx"),
-      path3.join(srcDir, filePath + ".tsx"),
-      path3.join(srcDir, filePath + ".jsx"),
-      path3.join(srcDir, "App.tsx"),
-      path3.join(srcDir, "App.jsx")
-    ];
-    for (const p of possiblePaths) {
-      if (fs3.existsSync(p)) {
-        return extractMetadata(p);
-      }
-    }
-    const rootPath = path3.join(srcDir, "root.tsx");
-    if (fs3.existsSync(rootPath)) {
-      return extractMetadata(rootPath);
-    }
-    return {};
-  };
-  const buildSeoHead = (routePath, metadata) => {
-    const meta = metadata || getRouteMetadata(routePath);
-    let headContent = "";
-    if (meta.title) {
-      headContent += `<title>${meta.title}</title>
-`;
-    } else {
-      headContent += `<title>Olova App</title>
-`;
-    }
-    if (meta.description) {
-      headContent += `<meta name="description" content="${meta.description}" />
-`;
-    }
-    if (meta.keywords) {
-      const keywords = Array.isArray(meta.keywords) ? meta.keywords.join(", ") : meta.keywords;
-      headContent += `<meta name="keywords" content="${keywords}" />
-`;
-    }
-    const jsonLdScript = generateJsonLd({ route: routePath, metadata: meta });
-    headContent += jsonLdScript + "\n";
-    headContent += `<style id="olova-critical">*{box-sizing:border-box}html{-webkit-text-size-adjust:100%;line-height:1.5}body{font-family:system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif}</style>
-`;
-    return headContent;
-  };
-  const buildBodyScripts = (routePath, metadata, isStatic) => {
-    const meta = metadata || getRouteMetadata(routePath);
-    const devBuildId = "dev-" + Date.now().toString(36);
-    return generateOlovaHydration({
-      route: routePath,
-      metadata: meta,
-      chunks: [],
-      isStatic: isStatic || false
-    }, devBuildId);
-  };
-  const renderShell = async () => {
-    if (!viteServer) return "";
-    try {
-      const serverModule = await viteServer.ssrLoadModule("olova/server");
-      if (serverModule?.renderShell) {
-        return serverModule.renderShell() || "";
-      }
-    } catch (e) {
-    }
-    return "";
-  };
-  const renderFullPage = async (routePath) => {
-    if (!viteServer) return { html: "", metadata: {} };
-    try {
-      const serverModule = await viteServer.ssrLoadModule("olova/server");
-      if (serverModule?.render) {
-        const result = await serverModule.render(routePath);
-        return {
-          html: result.html || "",
-          metadata: result.hydrationData?.metadata || {}
-        };
-      }
-    } catch (e) {
-      console.error("[Olova] Full page render error:", e.message);
-    }
-    return { html: "", metadata: {} };
-  };
-  const injectIntoHtml = (html, seoHead, bodyScripts) => {
-    let result = html;
-    if (result.includes("</head>")) {
-      result = result.replace("</head>", seoHead + "</head>");
-    }
-    if (result.includes("</body>")) {
-      result = result.replace(
-        "</body>",
-        bodyScripts + '<script type="module" src="/olova/client"></script>\n</body>'
-      );
-    } else {
-      result += bodyScripts + '<script type="module" src="/olova/client"></script>';
-    }
-    return result;
-  };
-  return {
-    name: "olova-virtual-html",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === "index.html" || id === "virtual:index.html" || id === "/index.html") {
-        return "virtual:olova-index.html";
-      }
-    },
-    load(id) {
-      if (id === "virtual:olova-index.html") {
-        return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  </head>
-  <body>
-    <script type="module" src="/olova/client"></script>
-  </body>
-</html>`;
-      }
-    },
-    configureServer(server) {
-      viteServer = server;
-      return () => {
-        server.middlewares.use(async (req, res, next) => {
-          const url = req.url || "/";
-          const accept = req.headers.accept || "";
-          if (!accept.includes("text/html")) {
-            return next();
-          }
-          if (url.startsWith("/@") || url.startsWith("/__") || url.startsWith("/node_modules")) {
-            return next();
-          }
-          if (/\.\w+$/.test(url) && !url.endsWith(".html")) {
-            return next();
-          }
-          const routePath = url.split("?")[0].replace(/\/+$/, "") || "/";
-          try {
-            const { isStatic, fileType } = isStaticRoute(routePath);
-            const routeMetadata = getRouteMetadata(routePath);
-            let finalHtml;
-            let metadata = { ...routeMetadata };
-            if (isStatic) {
-              const { html: fullHtml, metadata: ssrMetadata } = await renderFullPage(routePath);
-              metadata = { ...routeMetadata, ...ssrMetadata };
-              if (fullHtml) {
-                const seoHead = buildSeoHead(routePath, metadata);
-                const bodyScripts = buildBodyScripts(routePath, metadata, true);
-                finalHtml = injectIntoHtml(fullHtml, seoHead, bodyScripts);
-              } else {
-                const shellHtml = await renderShell();
-                const seoHead = buildSeoHead(routePath, metadata);
-                const bodyScripts = buildBodyScripts(routePath, metadata, true);
-                if (shellHtml) {
-                  finalHtml = injectIntoHtml(shellHtml, seoHead, bodyScripts);
-                } else {
-                  finalHtml = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${seoHead}
-  </head>
-  <body>
-    ${bodyScripts}
-    <script type="module" src="/olova/client"></script>
-  </body>
-</html>`;
-                }
-              }
-            } else {
-              const shellHtml = await renderShell();
-              const seoHead = buildSeoHead(routePath, metadata);
-              const bodyScripts = buildBodyScripts(routePath, metadata, false);
-              if (shellHtml) {
-                finalHtml = injectIntoHtml(shellHtml, seoHead, bodyScripts);
-              } else {
-                finalHtml = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${seoHead}
-  </head>
-  <body>
-    ${bodyScripts}
-    <script type="module" src="/olova/client"></script>
-  </body>
-</html>`;
-              }
-            }
-            if (!finalHtml.trim().toLowerCase().startsWith("<!doctype")) {
-              finalHtml = "<!DOCTYPE html>\n" + finalHtml;
-            }
-            const transformedHtml = await server.transformIndexHtml(url, finalHtml);
-            res.setHeader("Content-Type", "text/html");
-            res.statusCode = 200;
-            res.end(transformedHtml);
-          } catch (e) {
-            console.error("[Olova] Error:", e);
-            next(e);
-          }
-        });
-      };
-    }
-  };
-}
-
-// src/plugins/ssg.ts
-import { build } from "vite";
-import fs4 from "fs";
-import path4 from "path";
-import { pathToFileURL } from "url";
-
-// src/plugins/utils.ts
-function minifyHtml(html) {
-  return html.replace(/<!--(?!\[if).*?-->/gs, "").replace(/\s+/g, " ").replace(/> </g, "><").replace(/\s*(<[^>]+>)\s*/g, "$1").trim();
-}
-function generateBuildId() {
-  return Math.random().toString(36).substring(2, 15) + Date.now().toString(36);
-}
-function generateResourceHints() {
-  return `
-    <link rel="dns-prefetch" href="//fonts.googleapis.com">
-    <link rel="dns-prefetch" href="//fonts.gstatic.com">
-    <link rel="dns-prefetch" href="//cdn.jsdelivr.net">
-    <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    `.trim().replace(/\n\s+/g, "");
-}
-function generateCriticalCSS() {
-  return `<style id="olova-critical">
-    *{box-sizing:border-box;margin:0;padding:0}
-    html{-webkit-text-size-adjust:100%;line-height:1.5}
-    body{font-family:system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif}
-    img,video{max-width:100%;height:auto}
-    [hidden]{display:none!important}
-    </style>`.replace(/\n\s*/g, "");
-}
-function generateServiceWorkerScript() {
-  return `<script>if('serviceWorker'in navigator){window.addEventListener('load',()=>{navigator.serviceWorker.register('/sw.js').catch(()=>{})})}</script>`;
-}
-function generateServiceWorkerContent(buildId, assets) {
-  return `// Olova Service Worker v${buildId}
-const CACHE_NAME = 'olova-cache-${buildId}';
-const ASSETS = ${JSON.stringify(assets)};
-
-self.addEventListener('install', (e) => {
-    e.waitUntil(caches.open(CACHE_NAME).then(cache => cache.addAll(ASSETS)));
-    self.skipWaiting();
-});
-
-self.addEventListener('activate', (e) => {
-    e.waitUntil(caches.keys().then(keys => Promise.all(
-        keys.filter(k => k !== CACHE_NAME).map(k => caches.delete(k))
-    )));
-});
-
-self.addEventListener('fetch', (e) => {
-    e.respondWith(caches.match(e.request).then(r => r || fetch(e.request)));
-});
-`;
-}
-function generatePerformanceMeta() {
-  return `<meta http-equiv="x-dns-prefetch-control" content="on"><meta name="color-scheme" content="light dark">`;
-}
-
-// src/plugins/ssg.ts
-var colors2 = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  green: "\x1B[32m",
-  cyan: "\x1B[36m",
-  yellow: "\x1B[33m",
-  magenta: "\x1B[35m",
-  blue: "\x1B[34m",
-  red: "\x1B[31m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m",
-  bgGreen: "\x1B[42m",
-  bgCyan: "\x1B[46m",
-  bgMagenta: "\x1B[45m"
-};
-var symbols = {
-  success: "\u2713",
-  arrow: "\u2192",
-  bullet: "\u25CB",
-  filled: "\u25CF",
-  lambda: "\u03BB",
-  static: "\u25CB",
-  ssr: "\u25CF",
-  info: "\u2139"
-};
-function formatTime(ms) {
-  if (ms < 1) return "<1ms";
-  if (ms < 10) return `${ms.toFixed(1)}ms`;
-  if (ms < 1e3) return `${Math.round(ms)}ms`;
-  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
-  const mins = Math.floor(ms / 6e4);
-  const secs = Math.round(ms % 6e4 / 1e3);
-  return `${mins}m ${secs}s`;
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-var logger = {
-  header: (text) => {
-    console.log(`
-${colors2.bold}${colors2.white}${text}${colors2.reset}`);
-  },
-  info: (text) => {
-    console.log(`${colors2.cyan}${symbols.info}${colors2.reset} ${text}`);
-  },
-  success: (text) => {
-    console.log(`${colors2.green}${symbols.success}${colors2.reset} ${text}`);
-  },
-  route: (route, type, size, time) => {
-    const symbol = type === "static" ? symbols.static : symbols.ssr;
-    const color = type === "static" ? colors2.white : colors2.magenta;
-    const sizeStr = size ? ` ${colors2.dim}${formatBytes(size)}${colors2.reset}` : "";
-    const timeStr = time ? ` ${colors2.gray}(${formatTime(time)})${colors2.reset}` : "";
-    console.log(`${color}${symbol}${colors2.reset} ${route}${sizeStr}${timeStr}`);
-  },
-  step: (step, time) => {
-    const timeStr = time ? ` ${colors2.gray}${formatTime(time)}${colors2.reset}` : "";
-    console.log(`  ${colors2.dim}${symbols.arrow}${colors2.reset} ${step}${timeStr}`);
-  },
-  buildComplete: (totalRoutes, staticRoutes, totalTime) => {
-    console.log("");
-    console.log(`${colors2.bold}${colors2.green}${symbols.success} Build completed!${colors2.reset}`);
-    console.log("");
-    console.log(`  ${colors2.dim}Routes:${colors2.reset}  ${totalRoutes} total`);
-    console.log(`  ${colors2.dim}Static:${colors2.reset}  ${staticRoutes} prerendered`);
-    console.log(`  ${colors2.dim}Time:${colors2.reset}    ${formatTime(totalTime)}`);
-    console.log("");
-  },
-  legend: () => {
-    console.log(`${colors2.dim}${symbols.static} Static${colors2.reset}  ${colors2.dim}${symbols.ssr} SSR${colors2.reset}  ${colors2.dim}\u03BB ISR${colors2.reset}`);
-  },
-  banner: (buildId) => {
-    console.log("");
-    console.log(`${colors2.bold}${colors2.cyan}   \u{1F7E2} Olova${colors2.reset} ${colors2.dim}Static Export${colors2.reset}`);
-    console.log(`${colors2.dim}   Build ID: ${buildId}${colors2.reset}`);
-    console.log("");
-  },
-  error: (text) => {
-    console.log(`${colors2.red}\u2717${colors2.reset} ${colors2.red}${text}${colors2.reset}`);
-  },
-  warn: (text) => {
-    console.log(`${colors2.yellow}\u26A0${colors2.reset} ${colors2.yellow}${text}${colors2.reset}`);
-  }
-};
-function ssgPlugin() {
-  return {
-    name: "olova-ssg",
-    apply: "build",
-    config() {
-      if (process.env.IS_SSG_BUILD) {
-        return {};
-      }
-      return {
-        build: {
-          manifest: true,
-          rollupOptions: {
-            input: "index.html"
-          }
-        }
-      };
-    },
-    async closeBundle() {
-      if (process.env.IS_SSG_BUILD) return;
-      process.env.IS_SSG_BUILD = "true";
-      const totalStartTime = performance.now();
-      const buildId = generateBuildId();
-      logger.banner(buildId);
-      logger.header("Generating static pages...");
-      const serverBuildStart = performance.now();
-      try {
-        await build({
-          configFile: "./vite.config.ts",
-          build: {
-            ssr: true,
-            outDir: ".olova/server",
-            rollupOptions: {
-              input: "olova/server"
-            },
-            emptyOutDir: true,
-            reportCompressedSize: false
-          },
-          // Ensure virtual modules are bundled, not left as external imports
-          ssr: {
-            noExternal: true
-          },
-          logLevel: "silent"
-        });
-        logger.step("Server bundle compiled", performance.now() - serverBuildStart);
-      } catch (e) {
-        logger.error("SSG Build Failed");
-        console.error(e);
-        process.env.IS_SSG_BUILD = "";
-        return;
-      } finally {
-        process.env.IS_SSG_BUILD = "";
-      }
-      const scanStart = performance.now();
-      const allRoutes = [];
-      const scan = (dir, base = "") => {
-        if (!fs4.existsSync(dir)) return;
-        const entries = fs4.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path4.join(dir, entry.name);
-          if (entry.isDirectory()) {
-            const isRouteGroup = /^\(.+\)$/.test(entry.name);
-            if (isRouteGroup) {
-              scan(fullPath, base);
-            } else {
-              scan(fullPath, `${base}/${entry.name}`);
-            }
-          } else {
-            const ext = path4.extname(entry.name);
-            const supportedExts = [".tsx", ".jsx", ".html", ".md"];
-            if (supportedExts.includes(ext)) {
-              const nameNoExt = entry.name.replace(/\.(tsx|jsx|html|md)$/, "");
-              if (nameNoExt === "root") continue;
-              let route = base;
-              if (nameNoExt !== "index" && nameNoExt !== "App") {
-                route = `${base}/${nameNoExt}`;
-              }
-              if (route === "") route = "/";
-              if (route.includes("$")) continue;
-              if (ext === ".html" || ext === ".md") {
-                allRoutes.push({ route, isStatic: true, filePath: fullPath });
-              } else {
-                const fileContent = fs4.readFileSync(fullPath, "utf-8");
-                const firstLine = fileContent.trim().split("\n")[0].trim();
-                const isStatic = firstLine === '"static"' || firstLine === "'static'";
-                allRoutes.push({ route, isStatic, filePath: fullPath });
-              }
-            }
-          }
-        }
-      };
-      scan(path4.resolve("src"));
-      logger.step(`Found ${allRoutes.length} routes`, performance.now() - scanStart);
-      const serverDir = path4.resolve(".olova/server");
-      let serverFile = fs4.readdirSync(serverDir).find(
-        (f) => (f === "server.js" || f.includes("server-entry")) && f.endsWith(".js")
-      );
-      if (!serverFile) {
-        logger.error("Could not find server build artifact");
-        return;
-      }
-      const serverEntryPath = path4.join(serverDir, serverFile);
-      const { render, renderShell, renderShellWithMetadata, loadRoute } = await import(pathToFileURL(serverEntryPath).href);
-      const assetsStart = performance.now();
-      const distDir = path4.resolve(".olova/dist");
-      const clientHtmlPath = path4.join(distDir, "index.html");
-      let shellHtml = renderShell();
-      if (!shellHtml.startsWith("<!DOCTYPE html>")) {
-        shellHtml = `<!DOCTYPE html>
-${shellHtml}`;
-      }
-      let template = "";
-      if (fs4.existsSync(clientHtmlPath)) {
-        template = fs4.readFileSync(clientHtmlPath, "utf-8");
-      }
-      const manifestPath = path4.join(distDir, ".vite", "manifest.json");
-      let cssLinks = [];
-      let entryScript = "";
-      if (fs4.existsSync(manifestPath)) {
-        try {
-          const manifest = JSON.parse(fs4.readFileSync(manifestPath, "utf-8"));
-          for (const [key, value] of Object.entries(manifest)) {
-            const entry = value;
-            if (entry.css && entry.css.length > 0) {
-              for (const cssFile of entry.css) {
-                const cssLink = `<link rel="stylesheet" href="/${cssFile}" />`;
-                if (!cssLinks.includes(cssLink)) {
-                  cssLinks.push(cssLink);
-                }
-              }
-            }
-            if (entry.isEntry && entry.file) {
-              entryScript = `<script type="module" crossorigin src="/${entry.file}"></script>`;
-              logger.step(`Found entry script: ${entry.file}`);
-            }
-          }
-          if (cssLinks.length > 0) {
-            logger.step(`Found ${cssLinks.length} CSS file(s) from manifest`);
-          }
-          if (!entryScript) {
-            const staticDir = path4.join(distDir, "pro_olova_static");
-            if (fs4.existsSync(staticDir)) {
-              const files = fs4.readdirSync(staticDir);
-              const entryFile = files.find((f) => f.startsWith("olova-") && f.endsWith(".js"));
-              if (entryFile) {
-                entryScript = `<script type="module" crossorigin src="/pro_olova_static/${entryFile}"></script>`;
-                logger.step(`Found entry script (fallback): ${entryFile}`);
-              }
-            }
-          }
-        } catch (e) {
-          logger.warn("Could not parse manifest.json");
-        }
-      }
-      const scripts = template.match(/<script[\s\S]*?>[\s\S]*?<\/script>/gi) || [];
-      const links = template.match(/<link[\s\S]*?>/gi) || [];
-      const chunksDir = path4.join(distDir, "pro_olova_static", "chunks");
-      let preloadLinks = [];
-      if (fs4.existsSync(chunksDir)) {
-        const chunks = fs4.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
-        preloadLinks = chunks.map(
-          (chunk) => `<link rel="modulepreload" crossorigin href="/pro_olova_static/chunks/${chunk}" />`
-        );
-      }
-      const mainScriptMatch = template.match(/src="(\/pro_olova_static\/olova-[^"]+\.js)"/);
-      if (mainScriptMatch) {
-        preloadLinks.unshift(`<link rel="modulepreload" crossorigin href="${mainScriptMatch[1]}" />`);
-      }
-      const chunkList = [];
-      if (fs4.existsSync(chunksDir)) {
-        const chunks = fs4.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
-        chunks.forEach((chunk) => chunkList.push(`/pro_olova_static/chunks/${chunk}`));
-      }
-      const resourceHints = generateResourceHints();
-      const criticalCSS = generateCriticalCSS();
-      const performanceMeta = generatePerformanceMeta();
-      const swScript = generateServiceWorkerScript();
-      const performanceHead = [performanceMeta, resourceHints, criticalCSS].join("");
-      const allAssetsForSW = [
-        "/",
-        "/index.html",
-        ...chunkList,
-        ...cssLinks.map((l) => l.match(/href="([^"]+)"/)?.[1]).filter(Boolean),
-        ...links.map((l) => l.match(/href="([^"]+)"/)?.[1]).filter(Boolean),
-        ...entryScript.match(/src="([^"]+)"/) ? [entryScript.match(/src="([^"]+)"/)[1]] : []
-      ];
-      const swContent = generateServiceWorkerContent(buildId, allAssetsForSW);
-      fs4.writeFileSync(path4.join(distDir, "sw.js"), swContent);
-      const assets = [performanceHead, ...cssLinks, ...links, ...preloadLinks, ...scripts, entryScript, swScript].join("\n");
-      logger.step(`Assets optimized (${cssLinks.length} styles, ${preloadLinks.length} preloads, SW ready)`, performance.now() - assetsStart);
-      console.log("");
-      logger.header("Route");
-      logger.legend();
-      console.log("");
-      let staticCount = 0;
-      const routeResults = [];
-      for (const { route, isStatic } of allRoutes) {
-        const routeStart = performance.now();
-        let finalHtml = "";
-        let isFullRender = false;
-        try {
-          const { html, hydrationData } = await render(route);
-          if (html) {
-            finalHtml = html;
-            isFullRender = true;
-            staticCount++;
-            if (Object.keys(hydrationData.params || {}).length > 0) {
-              const scriptTag = `<script>window.__OLOVA_DATA__ = ${JSON.stringify(hydrationData)};</script>`;
-              if (finalHtml.includes("</body>")) {
-                finalHtml = finalHtml.replace("</body>", `${scriptTag}
-</body>`);
-              } else {
-                finalHtml += `
-${scriptTag}`;
-              }
-            }
-            const jsonLdScript = generateJsonLd({ route, metadata: hydrationData.metadata });
-            if (finalHtml.includes("</head>")) {
-              finalHtml = finalHtml.replace("</head>", `${jsonLdScript}${assets}
-</head>`);
-            } else {
-              finalHtml = finalHtml.replace("</body>", `${assets}
-</body>`);
-            }
-            if (!finalHtml.startsWith("<!DOCTYPE html>")) {
-              finalHtml = `<!DOCTYPE html>
-${finalHtml}`;
-            }
-            const flightScripts = generateOlovaHydration({
-              route,
-              metadata: hydrationData.metadata,
-              params: hydrationData.params,
-              chunks: chunkList,
-              isStatic: true
-            }, buildId);
-            if (finalHtml.includes("</body>")) {
-              finalHtml = finalHtml.replace("</body>", `${flightScripts}</body>`);
-            }
-            finalHtml = minifyHtml(finalHtml);
-          }
-        } catch (e) {
-          console.error(`[SSG] Render failed for ${route}:`, e);
-        }
-        if (!isFullRender) {
-          let pageMetadata = {};
-          try {
-            const routeResult = await loadRoute(route);
-            if (routeResult && routeResult.metadata) {
-              pageMetadata = routeResult.metadata;
-            }
-          } catch (e) {
-          }
-          finalHtml = renderShellWithMetadata(pageMetadata);
-          if (!finalHtml.startsWith("<!DOCTYPE html>")) {
-            finalHtml = `<!DOCTYPE html>
-${finalHtml}`;
-          }
-          const jsonLdScript = generateJsonLd({ route, metadata: pageMetadata });
-          if (finalHtml.includes("</head>")) {
-            finalHtml = finalHtml.replace("</head>", `${jsonLdScript}${assets}
-</head>`);
-          } else {
-            finalHtml = finalHtml.replace("</body>", `${assets}
-</body>`);
-          }
-          const flightScripts = generateOlovaHydration({
-            route,
-            metadata: pageMetadata,
-            chunks: chunkList,
-            isStatic: false
-          }, buildId);
-          if (finalHtml.includes("</body>")) {
-            finalHtml = finalHtml.replace("</body>", `${flightScripts}</body>`);
-          }
-        }
-        const outPath = path4.join(distDir, route === "/" ? "index.html" : `${route}/index.html`);
-        fs4.mkdirSync(path4.dirname(outPath), { recursive: true });
-        fs4.writeFileSync(outPath, finalHtml);
-        const routeTime = performance.now() - routeStart;
-        const routeSize = Buffer.byteLength(finalHtml, "utf8");
-        routeResults.push({ route, type: isStatic ? "static" : "ssr", size: routeSize, time: routeTime });
-        logger.route(route, isStatic ? "static" : "ssr", routeSize, routeTime);
-      }
-      const fallbackPath = path4.join(distDir, "404.html");
-      if (fs4.existsSync(clientHtmlPath)) {
-        fs4.copyFileSync(clientHtmlPath, fallbackPath);
-      }
-      const totalTime = performance.now() - totalStartTime;
-      logger.buildComplete(allRoutes.length, staticCount, totalTime);
-      console.log(`${colors2.dim}  Output:${colors2.reset}  .olova/dist`);
-      console.log("");
-    }
-  };
-}
-
-// src/plugins/clean-url.ts
-import fs5 from "fs";
-import path5 from "path";
-function cleanUrlPlugin() {
-  return {
-    name: "olova-clean-url",
-    configurePreviewServer(server) {
-      server.middlewares.use((req, res, next) => {
-        const urlPath = (req.url || "/").split("?")[0];
-        const distDir = path5.resolve(".olova/dist");
-        if (urlPath === "/") {
-          const indexPath2 = path5.join(distDir, "index.html");
-          if (fs5.existsSync(indexPath2)) {
-            const content = fs5.readFileSync(indexPath2, "utf-8");
-            res.setHeader("Content-Type", "text/html");
-            res.end(content);
-            return;
-          }
-        }
-        if (urlPath.includes(".")) return next();
-        const indexPath = path5.join(distDir, urlPath, "index.html");
-        if (fs5.existsSync(indexPath)) {
-          const content = fs5.readFileSync(indexPath, "utf-8");
-          res.setHeader("Content-Type", "text/html");
-          res.end(content);
-          return;
-        }
-        next();
-      });
-    }
-  };
-}
-
-// src/plugins/auto-generate.ts
-import fs6 from "fs";
-import path6 from "path";
-function toPascalCase(str) {
-  const cleanStr = str.replace(/^\$/, "");
-  return cleanStr.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-}
-function generateBoilerplate(folderName, isDynamic) {
-  const componentName = toPascalCase(folderName);
-  if (isDynamic) {
-    const paramName = folderName.replace(/^\$/, "");
-    return `import { useParams } from '../../route';
-
-export default function ${componentName}() {
-    const { ${paramName} } = useParams();
-    return (
-        <div>
-            <h1>${componentName} Page</h1>
-            <p>{${paramName}}</p>
-        </div>
-    );
-}
-`;
-  }
-  return `export default function ${componentName}() {
-    return (
-        <div>
-            <h1>${componentName} Page</h1>
-            <p>Welcome to ${componentName}</p>
-        </div>
-    );
-}
-`;
-}
-function autoGeneratePlugin() {
-  let srcDir;
-  return {
-    name: "olova-auto-generate",
-    configResolved(config) {
-      srcDir = path6.resolve(config.root, "src");
-    },
-    configureServer(server) {
-      console.log(
-        "\x1B[36m[olova] Auto-generate plugin active - watching for new route files\x1B[0m"
-      );
-      server.watcher.on("add", (filePath) => {
-        const normalizedPath = path6.normalize(filePath);
-        const normalizedSrcDir = path6.normalize(srcDir);
-        const ext = path6.extname(normalizedPath);
-        if (ext !== ".tsx" && ext !== ".jsx") {
-          return;
-        }
-        if (!normalizedPath.startsWith(normalizedSrcDir)) {
-          return;
-        }
-        const fileName = path6.basename(normalizedPath, ext);
-        if (fileName !== "index") {
-          return;
-        }
-        const folderPath = path6.dirname(normalizedPath);
-        const folderName = path6.basename(folderPath);
-        if (folderName === "src" || folderName.startsWith("(")) {
-          return;
-        }
-        try {
-          fs6.statSync(normalizedPath);
-          const content = fs6.readFileSync(normalizedPath, "utf-8");
-          if (content.trim().length > 10) {
-            return;
-          }
-        } catch (err) {
-          return;
-        }
-        const isDynamic = folderName.startsWith("$");
-        const boilerplate = generateBoilerplate(folderName, isDynamic);
-        try {
-          fs6.writeFileSync(normalizedPath, boilerplate, "utf-8");
-          console.log(
-            `\x1B[32m\u2713 [olova] Auto-generated: ${folderName}/index${ext}\x1B[0m`
-          );
-        } catch (err) {
-          console.error(
-            `\x1B[31m\u2717 [olova] Failed to write boilerplate:\x1B[0m`,
-            err
-          );
-        }
-      });
-    }
-  };
-}
-
-// src/plugins/error-overlay.ts
-import path7 from "path";
-function proactiveErrorPlugin() {
-  return {
-    name: "olova-proactive-error",
-    enforce: "post",
-    configureServer(devServer) {
-      const srcDir = path7.resolve(process.cwd(), "src");
-      const validateFile = async (filePath) => {
-        if (!filePath.startsWith(srcDir)) return;
-        if (!/\.(tsx?|jsx?)$/.test(filePath)) return;
-        const relativePath = path7.relative(srcDir, filePath);
-        console.log("\x1B[36m[olova]\x1B[0m Checking:", relativePath);
-        try {
-          const url = "/" + path7.relative(process.cwd(), filePath).replace(/\\/g, "/");
-          await devServer.transformRequest(url);
-          console.log("\x1B[32m[olova]\x1B[0m \u2713", relativePath, "OK");
-        } catch (err) {
-          console.log("\x1B[31m[olova]\x1B[0m \u2717", relativePath);
-          devServer.ws.send({
-            type: "error",
-            err: {
-              message: err.message || String(err),
-              stack: err.stack || "",
-              id: err.id || filePath,
-              frame: err.frame || "",
-              plugin: err.plugin || "olova",
-              loc: err.loc || void 0
-            }
-          });
-        }
-      };
-      devServer.watcher.on("change", async (filePath) => {
-        await new Promise((r) => setTimeout(r, 50));
-        await validateFile(filePath);
-      });
-      devServer.watcher.on("add", async (filePath) => {
-        await new Promise((r) => setTimeout(r, 100));
-        await validateFile(filePath);
-      });
-    }
-  };
-}
-
-// src/plugins/index.ts
-function olovaPlugins() {
-  return [
-    configPlugin(),
-    // Must be first - creates .olova folder and sets config
-    routerPlugin(),
-    frameworkPlugin(),
-    virtualHtmlPlugin(),
-    ssgPlugin(),
-    cleanUrlPlugin(),
-    autoGeneratePlugin(),
-    // Auto-generates boilerplate for new route files
-    proactiveErrorPlugin()
-    // Checks all files on save for instant error detection
-  ];
-}
-
-// src/plugins/terminal.ts
-var colors3 = {
-  // Reset
-  reset: "\x1B[0m",
-  // Styles
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  italic: "\x1B[3m",
-  underline: "\x1B[4m",
-  // Foreground colors
-  black: "\x1B[30m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m",
-  // Background colors
-  bgBlack: "\x1B[40m",
-  bgRed: "\x1B[41m",
-  bgGreen: "\x1B[42m",
-  bgYellow: "\x1B[43m",
-  bgBlue: "\x1B[44m",
-  bgMagenta: "\x1B[45m",
-  bgCyan: "\x1B[46m",
-  bgWhite: "\x1B[47m"
-};
-var symbols2 = {
-  success: "\u2713",
-  error: "\u2717",
-  warning: "\u26A0",
-  info: "\u2139",
-  arrow: "\u2192",
-  arrowRight: "\u279C",
-  bullet: "\u25CB",
-  filled: "\u25CF",
-  lambda: "\u03BB",
-  triangle: "\u{1F7E2}",
-  square: "\u25A0",
-  diamond: "\u25C6",
-  star: "\u2605",
-  check: "\u2714",
-  cross: "\u2716",
-  pointer: "\u276F"
-};
-function formatTime2(ms) {
-  if (ms < 1) return "<1ms";
-  if (ms < 10) return `${ms.toFixed(1)}ms`;
-  if (ms < 1e3) return `${Math.round(ms)}ms`;
-  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
-  const mins = Math.floor(ms / 6e4);
-  const secs = Math.round(ms % 6e4 / 1e3);
-  return `${mins}m ${secs}s`;
-}
-function formatBytes2(bytes) {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "kB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
-}
-var logger2 = {
-  // Print banner
-  banner: (name, version = "1.0.0") => {
-    console.log("");
-    console.log(`  ${colors3.bold}${colors3.cyan}${symbols2.triangle} ${name}${colors3.reset} ${colors3.dim}v${version}${colors3.reset}`);
-    console.log("");
-  },
-  // Print header
-  header: (text) => {
-    console.log(`
-${colors3.bold}${colors3.white}${text}${colors3.reset}`);
-  },
-  // Info message
-  info: (text) => {
-    console.log(`${colors3.cyan}${symbols2.info}${colors3.reset} ${text}`);
-  },
-  // Success message
-  success: (text, time) => {
-    const timeStr = time !== void 0 ? ` ${colors3.dim}${formatTime2(time)}${colors3.reset}` : "";
-    console.log(`${colors3.green}${symbols2.success}${colors3.reset} ${text}${timeStr}`);
-  },
-  // Error message
-  error: (text) => {
-    console.log(`${colors3.red}${symbols2.error}${colors3.reset} ${colors3.red}${text}${colors3.reset}`);
-  },
-  // Warning message
-  warn: (text) => {
-    console.log(`${colors3.yellow}${symbols2.warning}${colors3.reset} ${colors3.yellow}${text}${colors3.reset}`);
-  },
-  // Step in a process
-  step: (text, time) => {
-    const timeStr = time !== void 0 ? ` ${colors3.gray}${formatTime2(time)}${colors3.reset}` : "";
-    console.log(`  ${colors3.dim}${symbols2.arrow}${colors3.reset} ${text}${timeStr}`);
-  },
-  // Route log (for SSG)
-  route: (route, type, size, time) => {
-    const symbol = type === "static" ? symbols2.bullet : type === "ssr" ? symbols2.filled : symbols2.lambda;
-    const color = type === "static" ? colors3.white : type === "ssr" ? colors3.magenta : colors3.cyan;
-    const sizeStr = size ? ` ${colors3.dim}${formatBytes2(size)}${colors3.reset}` : "";
-    const timeStr = time ? ` ${colors3.gray}(${formatTime2(time)})${colors3.reset}` : "";
-    console.log(`${color}${symbol}${colors3.reset} ${route}${sizeStr}${timeStr}`);
-  },
-  // Indent text  
-  indent: (text, level = 1) => {
-    console.log(`${"  ".repeat(level)}${text}`);
-  },
-  // Empty line
-  newline: () => console.log(""),
-  // Dim text
-  dim: (text) => `${colors3.dim}${text}${colors3.reset}`,
-  // Bold text  
-  bold: (text) => `${colors3.bold}${text}${colors3.reset}`,
-  // Colored text
-  cyan: (text) => `${colors3.cyan}${text}${colors3.reset}`,
-  green: (text) => `${colors3.green}${text}${colors3.reset}`,
-  yellow: (text) => `${colors3.yellow}${text}${colors3.reset}`,
-  red: (text) => `${colors3.red}${text}${colors3.reset}`,
-  magenta: (text) => `${colors3.magenta}${text}${colors3.reset}`
-};
-function createTimer() {
-  const start = performance.now();
-  return {
-    elapsed: () => performance.now() - start,
-    format: () => formatTime2(performance.now() - start)
-  };
-}
-export {
-  colors3 as colors,
-  createTimer,
-  formatBytes2 as formatBytes,
-  formatTime2 as formatTime,
-  generateBuildId,
-  generateCriticalCSS,
-  generateJsonLd,
-  generateOlovaHydration,
-  generatePerformanceMeta,
-  generateResourceHints,
-  generateServiceWorkerContent,
-  generateServiceWorkerScript,
-  logger2 as logger,
-  minifyHtml,
-  olovaPlugins,
-  parseFlightData,
-  symbols2 as symbols
-};
-//# sourceMappingURL=vite.js.map