olovaplugin 1.0.5 → 1.0.7

package/dist/olova-plugins.mjs

@@ -0,0 +1,1540 @@
+// router/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}\u25B2 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";
+                  }
+                  return "vendor";
+                }
+              }
+            }
+          }
+        },
+        preview: {
+          port: 4173,
+          strictPort: false
+        }
+      };
+    },
+    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);
+      });
+    }
+  };
+}
+
+// router/router.ts
+import fs2 from "fs";
+import path2 from "path";
+function routerPlugin() {
+  const virtualModuleId = "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",
+    // Configure dev server to watch for file changes
+    configureServer(devServer) {
+      server = devServer;
+      const srcDir = path2.resolve(__dirname, "..", "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(__dirname, "..", "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(__dirname, "..", "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)$/, "");
+                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")}
+};`;
+      }
+    }
+  };
+}
+
+// router/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",
+    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 '/route.tsx';
+
+// 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__ || {};
+  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 rootElement = document.getElementById('root');
+  const app = (
+    <React.StrictMode>
+       <Layout>
+         <Router url={path} initialComponent={Component} initialParams={params} onRouteChange={(newMetadata) => generateSeoTags(newMetadata)} />
+       </Layout>
+    </React.StrictMode>
+  );
+
+  if (rootElement && rootElement.innerHTML.trim() !== "") {
+    console.log("[Olova] Hydrating pre-rendered content");
+    hydrateRoot(document, app);
+  } else {
+    console.log("[Olova] Rendering client-side (no SSR content found)");
+    createRoot(document).render(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 { Router, loadRoute } from '/route.tsx';
+
+// Generate SEO head content
+function generateSeoHead(metadata) {
+  const meta = { ...defaultMetadata, ...metadata };
+  let head = '';
+  
+  // Title
+  if (meta.title) {
+    head += \`<title>\${meta.title}</title>\\n\`;
+  }
+  
+  // Basic meta
+  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\`;
+  }
+  
+  // Open Graph
+  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\`;
+      });
+    }
+  }
+  
+  // Twitter Card
+  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;
+}
+
+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;
+  
+  // Generate the SEO head content
+  const seoHead = generateSeoHead(metadata);
+  
+  let html = renderToString(
+    <Layout>
+      <Router url={url} initialComponent={Component} initialParams={params} />
+    </Layout>
+  );
+  
+  // Inject SEO tags into head (framework handles this automatically)
+  if (html.includes('</head>')) {
+    html = html.replace('</head>', seoHead + '</head>');
+  }
+  
+  return { html, hydrationData: { params, metadata } };
+}
+
+// Render empty shell from Layout (for client-only pages)
+export function renderShell() {
+  const seoHead = generateSeoHead({});
+  let html = renderToString(<Layout>{null}</Layout>);
+  if (html.includes('</head>')) {
+    html = html.replace('</head>', seoHead + '</head>');
+  }
+  return html;
+}
+
+// Render shell WITH metadata for client-only pages that have metadata exports
+// This enables SEO pre-rendering even for pages without "static" directive
+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;
+}
+
+// Re-export loadRoute so it can be used during SSG to extract metadata from any route
+export { loadRoute };`;
+        const result = await transformWithEsbuild(code, "olova-server.tsx", {
+          loader: "tsx",
+          jsx: "automatic"
+        });
+        return result.code;
+      }
+    }
+  };
+}
+
+// router/virtual-html.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// router/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;
+}
+
+// router/virtual-html.ts
+function virtualHtmlPlugin() {
+  const htmlTemplate = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>My Framework</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">
+      import '/olova/client';
+    </script>
+  </body>
+</html>`;
+  return {
+    name: "olova-virtual-html",
+    enforce: "pre",
+    // Handle virtual index.html resolution for build
+    resolveId(id) {
+      if (id === "index.html" || id === "virtual:index.html" || id === "olova.html") {
+        return "olova.html";
+      }
+    },
+    load(id) {
+      if (id === "olova.html" || id === "virtual:index.html") {
+        return htmlTemplate;
+      }
+    },
+    // Serve HTML for all routes in dev mode with SSR (like Next.js)
+    configureServer(server) {
+      const isStaticRoute = (routePath) => {
+        const srcDir = path3.resolve("src");
+        let filePath = routePath === "/" ? "index" : routePath.slice(1);
+        const staticPaths = [
+          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 staticPaths) {
+          if (fs3.existsSync(p)) {
+            return true;
+          }
+        }
+        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)) {
+            const content = fs3.readFileSync(p, "utf-8");
+            const firstLine = content.trim().split("\n")[0].trim();
+            return firstLine === '"static"' || firstLine === "'static'";
+          }
+        }
+        return false;
+      };
+      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];
+          const shouldSSR = isStaticRoute(routePath);
+          try {
+            if (shouldSSR) {
+              const { render } = await server.ssrLoadModule("olova/server");
+              const { html: ssrHtml, hydrationData } = await render(routePath);
+              let fullHtml = ssrHtml;
+              const hydrationScript = `<script>window.__OLOVA_DATA__ = ${JSON.stringify(hydrationData)};</script>`;
+              fullHtml = fullHtml.replace("</body>", `${hydrationScript}
+</body>`);
+              const clientScript = `<script type="module" src="/olova/client"></script>`;
+              fullHtml = fullHtml.replace("</body>", `${clientScript}
+</body>`);
+              const devBuildId = "dev-" + Date.now().toString(36);
+              const flightScripts = generateOlovaHydration({
+                route: routePath,
+                metadata: hydrationData.metadata,
+                params: hydrationData.params,
+                chunks: []
+              }, devBuildId);
+              fullHtml = fullHtml.replace("</body>", `${flightScripts}</body>`);
+              const jsonLdScript = generateJsonLd({ route: routePath, metadata: hydrationData.metadata });
+              fullHtml = fullHtml.replace("</head>", `${jsonLdScript}</head>`);
+              const html = await server.transformIndexHtml(url, fullHtml);
+              res.setHeader("Content-Type", "text/html");
+              res.statusCode = 200;
+              res.end(html);
+            } else {
+              const { renderShellWithMetadata } = await server.ssrLoadModule("olova/server");
+              const { loadRoute: clientLoadRoute } = await server.ssrLoadModule("/route.tsx");
+              let pageMetadata = {};
+              try {
+                const result = await clientLoadRoute(routePath);
+                if (result && result.metadata) {
+                  pageMetadata = result.metadata;
+                }
+              } catch (e) {
+              }
+              let fullHtml = renderShellWithMetadata(pageMetadata);
+              const clientScript = `<script type="module" src="/olova/client"></script>`;
+              fullHtml = fullHtml.replace("</body>", `${clientScript}
+</body>`);
+              const devBuildId = "dev-" + Date.now().toString(36);
+              const flightScripts = generateOlovaHydration({
+                route: routePath,
+                metadata: pageMetadata,
+                chunks: []
+              }, devBuildId);
+              fullHtml = fullHtml.replace("</body>", `${flightScripts}</body>`);
+              const jsonLdScript = generateJsonLd({ route: routePath, metadata: pageMetadata });
+              fullHtml = fullHtml.replace("</head>", `${jsonLdScript}</head>`);
+              const html = await server.transformIndexHtml(url, fullHtml);
+              res.setHeader("Content-Type", "text/html");
+              res.statusCode = 200;
+              res.end(html);
+            }
+          } catch (e) {
+            console.error("[Olova] Error:", e);
+            try {
+              const html = await server.transformIndexHtml(url, htmlTemplate);
+              res.setHeader("Content-Type", "text/html");
+              res.statusCode = 200;
+              res.end(html);
+            } catch (e2) {
+              next(e2);
+            }
+          }
+        });
+      };
+    }
+  };
+}
+
+// router/ssg.ts
+import { build } from "vite";
+import fs4 from "fs";
+import path4 from "path";
+import { pathToFileURL } from "url";
+
+// router/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">`;
+}
+
+// router/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}   \u25B2 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
+          },
+          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)$/, "");
+              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, "olova.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 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,
+        ...links.map((l) => l.match(/href="([^"]+)"/)?.[1]).filter(Boolean)
+      ];
+      const swContent = generateServiceWorkerContent(buildId, allAssetsForSW);
+      fs4.writeFileSync(path4.join(distDir, "sw.js"), swContent);
+      const assets = [performanceHead, ...links, ...preloadLinks, ...scripts, swScript].join("\n");
+      logger.step(`Assets optimized (${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 = "";
+        if (isStatic) {
+          staticCount++;
+          const { html, hydrationData } = await render(route);
+          finalHtml = html;
+          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);
+        } else {
+          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>`);
+          }
+          finalHtml = minifyHtml(finalHtml);
+        }
+        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("");
+    }
+  };
+}
+
+// router/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();
+      });
+    }
+  };
+}
+
+// router/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
+          );
+        }
+      });
+    }
+  };
+}
+
+// router/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);
+      });
+    }
+  };
+}
+
+// router/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: "\u25B2",
+  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)
+  };
+}
+
+// router/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
+  ];
+}
+export {
+  autoGeneratePlugin,
+  cleanUrlPlugin,
+  colors3 as colors,
+  configPlugin,
+  createTimer,
+  formatBytes2 as formatBytes,
+  formatTime2 as formatTime,
+  frameworkPlugin,
+  generateBuildId,
+  generateCriticalCSS,
+  generateJsonLd,
+  generateOlovaHydration,
+  generatePerformanceMeta,
+  generateResourceHints,
+  generateServiceWorkerContent,
+  generateServiceWorkerScript,
+  logger2 as logger,
+  minifyHtml,
+  olovaPlugins,
+  parseFlightData,
+  proactiveErrorPlugin,
+  routerPlugin,
+  ssgPlugin,
+  symbols2 as symbols,
+  virtualHtmlPlugin
+};