olova 2.0.54 → 2.0.56

package/dist/plugin/index.js

@@ -1,1490 +0,0 @@
-// src/plugin/hooks/config.ts
-import path7 from "path";
-
-// src/plugin/config.ts
-import fs from "fs";
-import path from "path";
-import { pathToFileURL } from "url";
-import { createRequire } from "module";
-var userConfig = {};
-async function loadOlovaConfig() {
-  const configPath = path.resolve(process.cwd(), "olova.config.ts");
-  if (!fs.existsSync(configPath)) {
-    console.log("  \u26A0 No olova.config.ts found, using defaults");
-    return {};
-  }
-  try {
-    const require2 = createRequire(import.meta.url);
-    const esbuild = require2("esbuild");
-    const result = await esbuild.build({
-      entryPoints: [configPath],
-      bundle: true,
-      platform: "node",
-      format: "cjs",
-      write: false,
-      external: [
-        "vite",
-        "esbuild",
-        "util",
-        "path",
-        "fs",
-        "url",
-        "os",
-        "crypto",
-        "stream",
-        "events",
-        "buffer",
-        "querystring",
-        "http",
-        "https",
-        "net",
-        "tls",
-        "child_process",
-        "cluster",
-        "dgram",
-        "dns",
-        "domain",
-        "readline",
-        "repl",
-        "tty",
-        "v8",
-        "vm",
-        "zlib",
-        "assert",
-        "async_hooks",
-        "console",
-        "constants",
-        "module",
-        "perf_hooks",
-        "process",
-        "string_decoder",
-        "timers",
-        "trace_events",
-        "worker_threads"
-      ]
-    });
-    const code = result.outputFiles[0].text;
-    const tempPath = path.resolve(process.cwd(), ".olova/temp-config.cjs");
-    const olovaDir = path.resolve(process.cwd(), ".olova");
-    if (!fs.existsSync(olovaDir)) {
-      fs.mkdirSync(olovaDir, { recursive: true });
-    }
-    fs.writeFileSync(tempPath, code);
-    const mod = await import(pathToFileURL(tempPath).href);
-    fs.unlinkSync(tempPath);
-    userConfig = mod.default?.default || mod.default || {};
-    return userConfig;
-  } catch (err) {
-    console.error("  \u26A0 Failed to load olova.config.ts:", err.message);
-    return {};
-  }
-}
-function getConfig() {
-  return {
-    outDir: ".olova/dist",
-    basePath: "/",
-    trailingSlash: false,
-    experimental: {
-      prefetch: true,
-      ...userConfig.experimental
-    },
-    staticGeneration: {
-      timeout: 3e4,
-      fallback: "blocking",
-      ...userConfig.staticGeneration
-    },
-    ...userConfig
-  };
-}
-function getUserConfig() {
-  return userConfig;
-}
-
-// src/plugin/css/detection.ts
-import fs2 from "fs";
-import path2 from "path";
-async function detectTailwindConfig(baseDir = process.cwd()) {
-  const configFiles = ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs", "tailwind.config.cjs"];
-  for (const configFile of configFiles) {
-    const configPath = path2.resolve(baseDir, configFile);
-    if (fs2.existsSync(configPath)) {
-      const content = fs2.readFileSync(configPath, "utf-8");
-      const isV4 = content.includes("@tailwindcss") || content.includes("theme:");
-      return { detected: true, configPath, version: isV4 ? "4" : "3" };
-    }
-  }
-  const packageJsonPath = path2.resolve(baseDir, "package.json");
-  if (fs2.existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (deps["tailwindcss"]) {
-        const version = deps["tailwindcss"].replace(/^[\^~>=<]+/, "");
-        return { detected: true, version: version.startsWith("4") ? "4" : "3" };
-      }
-    } catch {
-    }
-  }
-  return { detected: false };
-}
-async function detectPostCSSConfig(baseDir = process.cwd()) {
-  const configFiles = ["postcss.config.js", "postcss.config.cjs", "postcss.config.mjs", "postcss.config.ts", ".postcssrc", ".postcssrc.js", ".postcssrc.json"];
-  for (const configFile of configFiles) {
-    const configPath = path2.resolve(baseDir, configFile);
-    if (fs2.existsSync(configPath)) return { detected: true, configPath };
-  }
-  return { detected: false };
-}
-
-// src/plugin/css/collection.ts
-import fs3 from "fs";
-import path3 from "path";
-function collectCSSFiles(srcDir) {
-  const globalCSS = [];
-  const cssModules = [];
-  function scanDirectory(dir) {
-    if (!fs3.existsSync(dir)) return;
-    const entries = fs3.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        scanDirectory(fullPath);
-      } else if (entry.isFile()) {
-        if (entry.name.endsWith(".module.css") || entry.name.endsWith(".module.scss")) {
-          cssModules.push(fullPath);
-        } else if (entry.name.endsWith(".css") || entry.name.endsWith(".scss")) {
-          if (dir === srcDir) globalCSS.push(fullPath);
-        }
-      }
-    }
-  }
-  scanDirectory(srcDir);
-  return { globalCSS, cssModules };
-}
-function getCSSForBuild(outDir) {
-  const cssFiles = [];
-  function scanCSSDir(dir, basePath) {
-    if (!fs3.existsSync(dir)) return;
-    const entries = fs3.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) scanCSSDir(path3.join(dir, entry.name), basePath + entry.name + "/");
-      else if (entry.isFile() && entry.name.endsWith(".css")) cssFiles.push(basePath + entry.name);
-    }
-  }
-  const olovaCssDir = path3.join(outDir, "_olova", "static", "css");
-  if (fs3.existsSync(olovaCssDir)) scanCSSDir(olovaCssDir, "/_olova/static/css/");
-  const legacyCssDir = path3.join(outDir, "assets", "css");
-  if (cssFiles.length === 0 && fs3.existsSync(legacyCssDir)) scanCSSDir(legacyCssDir, "/assets/css/");
-  return cssFiles;
-}
-
-// src/plugin/css/generator.ts
-import path4 from "path";
-function generateCSSLinks(cssFiles, basePath = "/") {
-  return cssFiles.map((file) => {
-    const href = basePath + file.replace(/\\/g, "/");
-    return `<link rel="stylesheet" href="${href}" />`;
-  }).join("\n    ");
-}
-function generateCSSImports(cssFiles, srcDir) {
-  return cssFiles.map((file) => {
-    const relativePath = path4.relative(srcDir, file).replace(/\\/g, "/");
-    return `import '@/${relativePath}';`;
-  }).join("\n");
-}
-
-// src/plugin/css/config.ts
-function createDefaultPostCSSConfig(tailwindResult) {
-  const plugins = [];
-  if (tailwindResult.detected && tailwindResult.version !== "4") {
-    plugins.push(["tailwindcss", tailwindResult.configPath ? { config: tailwindResult.configPath } : {}]);
-  }
-  if (plugins.length > 0) plugins.push(["autoprefixer", {}]);
-  return plugins.length > 0 ? { plugins } : void 0;
-}
-async function createViteCSSConfig(cssConfig = {}, baseDir = process.cwd()) {
-  const tailwindResult = cssConfig.tailwind !== false ? await detectTailwindConfig(baseDir) : { detected: false };
-  const postcssResult = await detectPostCSSConfig(baseDir);
-  const cssOptions = {
-    modules: cssConfig.modules !== false ? { localsConvention: "camelCaseOnly", generateScopedName: "[name]__[local]___[hash:base64:5]" } : false
-  };
-  if (cssConfig.postcss !== false && !postcssResult.detected) {
-    cssOptions.postcss = createDefaultPostCSSConfig(tailwindResult);
-  }
-  return cssOptions;
-}
-
-// src/plugin/css/utils.ts
-import path5 from "path";
-function isCSSModule(filePath) {
-  return /\.module\.(css|scss|sass|less)$/.test(filePath);
-}
-function isCSSFile(filePath) {
-  return /\.(css|scss|sass|less)$/.test(filePath);
-}
-function logCSSStatus(tailwindResult, postcssResult, globalCSS) {
-  console.log("\n  \x1B[1m\x1B[36m\u{1F3A8} CSS Configuration\x1B[0m");
-  if (tailwindResult.detected) console.log(`  \u2713 Tailwind CSS ${tailwindResult.version === "4" ? "v4" : "v3"} detected`);
-  if (postcssResult.detected) console.log(`  \u2713 PostCSS config found: ${path5.basename(postcssResult.configPath)}`);
-  else console.log("  \u25CB Using default PostCSS config (autoprefixer)");
-  if (globalCSS.length > 0) console.log(`  \u2713 Global CSS files: ${globalCSS.map((f) => path5.basename(f)).join(", ")}`);
-  console.log("");
-}
-
-// src/plugin/chunks/collector.ts
-function createChunkCollector() {
-  return {
-    routes: /* @__PURE__ */ new Map(),
-    shared: /* @__PURE__ */ new Set(),
-    assets: /* @__PURE__ */ new Map(),
-    framework: { react: null, reactDom: null, scheduler: null, router: null },
-    chunkGroups: /* @__PURE__ */ new Map()
-  };
-}
-function addRouteChunk(collector, routePath, chunkFile, size, isStatic = false, isDynamic = false, css = [], dependencies = [], priority = "normal") {
-  collector.routes.set(routePath, { chunk: chunkFile, size, isStatic, isDynamic, css, dependencies, priority });
-}
-function addSharedChunk(collector, chunkFile) {
-  collector.shared.add(chunkFile);
-}
-function trackFrameworkChunk(collector, chunkName, fileName) {
-  if (chunkName === "framework-react") collector.framework.react = fileName;
-  else if (chunkName === "framework-react-dom") collector.framework.reactDom = fileName;
-  else if (chunkName === "framework-scheduler") collector.framework.scheduler = fileName;
-}
-function addToChunkGroup(collector, groupName, chunkFile) {
-  if (!collector.chunkGroups.has(groupName)) collector.chunkGroups.set(groupName, /* @__PURE__ */ new Set());
-  collector.chunkGroups.get(groupName).add(chunkFile);
-}
-
-// src/plugin/chunks/manifest.ts
-import fs4 from "fs";
-import path6 from "path";
-function generatePreloadHints(chunk, css, dependencies) {
-  const hints = [{ href: chunk, as: "script", priority: "critical", crossorigin: true }];
-  for (const cssFile of css) hints.push({ href: cssFile, as: "style", priority: "high" });
-  for (const dep of dependencies) hints.push({ href: dep.chunk, as: "script", priority: dep.priority, crossorigin: true });
-  return hints;
-}
-function generateChunkManifest(collector) {
-  const routes = {};
-  const preloadMap = {};
-  collector.routes.forEach((info, routePath) => {
-    const preloadHints = generatePreloadHints(info.chunk, info.css, info.dependencies);
-    routes[routePath] = { ...info, preloadHints };
-    preloadMap[routePath] = preloadHints;
-  });
-  const assets = {};
-  collector.assets.forEach((info, fileName) => {
-    assets[fileName] = info;
-  });
-  const chunkGroups = {};
-  collector.chunkGroups.forEach((chunks, groupName) => {
-    chunkGroups[groupName] = Array.from(chunks);
-  });
-  return { version: 2, buildTime: (/* @__PURE__ */ new Date()).toISOString(), routes, shared: Array.from(collector.shared), assets, framework: collector.framework, preloadMap, chunkGroups };
-}
-function writeChunkManifest(outDir, manifest) {
-  const olovaDir = path6.join(outDir, "_olova");
-  if (!fs4.existsSync(olovaDir)) fs4.mkdirSync(olovaDir, { recursive: true });
-  fs4.writeFileSync(path6.join(olovaDir, "chunks-manifest.json"), JSON.stringify(manifest, null, 2));
-  console.log(`  \u2713 Generated chunks-manifest.json (${Object.keys(manifest.routes).length} routes)`);
-}
-
-// src/plugin/chunks/utils.ts
-function routePathToChunkName(routePath) {
-  if (routePath === "/") return "index";
-  return routePath.replace(/^\//, "").replace(/\[\.\.\.(\w+)\]/g, "$1").replace(/\[(\w+)\]/g, "$1").replace(/:/g, "").replace(/\*/g, "").replace(/\//g, "-").toLowerCase();
-}
-function isPageModule(id, srcDir) {
-  if (!id.includes(srcDir)) return false;
-  const relativePath = id.replace(srcDir, "").replace(/\\/g, "/");
-  return /\/page\.(tsx?|jsx?)$/.test(relativePath);
-}
-function extractRoutePath(id, srcDir) {
-  if (!isPageModule(id, srcDir)) return null;
-  const relativePath = id.replace(srcDir, "").replace(/\\/g, "/").replace(/\/page\.(tsx?|jsx?)$/, "");
-  if (relativePath === "" || relativePath === "/") return "/";
-  return relativePath.replace(/\[\.\.\.(\w+)\]/g, "*$1").replace(/\[(\w+)\]/g, ":$1");
-}
-
-// src/plugin/chunks/manual.ts
-var isOfType = (id, srcDir, pattern) => {
-  if (!id.includes(srcDir)) return false;
-  return pattern.test(id.replace(srcDir, "").replace(/\\/g, "/"));
-};
-var getVendorChunkGroup = (packageName) => {
-  if (packageName === "react" || packageName.startsWith("react-")) return `framework-${packageName}`;
-  if (packageName === "scheduler") return "framework-scheduler";
-  const groups = {
-    "vendor-ui": ["@radix-ui", "@headlessui", "@heroicons", "lucide-react", "clsx", "class-variance-authority"],
-    "vendor-forms": ["react-hook-form", "zod", "yup", "@hookform"],
-    "vendor-date": ["date-fns", "dayjs", "moment", "luxon"],
-    "vendor-animation": ["framer-motion", "gsap", "animejs", "@react-spring"],
-    "vendor-state": ["zustand", "jotai", "recoil", "@tanstack/query", "swr"]
-  };
-  for (const [group, libs] of Object.entries(groups)) {
-    if (libs.some((lib) => packageName.startsWith(lib))) return group;
-  }
-  return `vendor-${packageName}`;
-};
-function createManualChunks(srcDir) {
-  const normSrc = srcDir.replace(/\\/g, "/");
-  return (id) => {
-    const normId = id.replace(/\\/g, "/");
-    if (normId.includes("node_modules/react-dom")) return "framework-react-dom";
-    if (normId.includes("node_modules/react/")) return "framework-react";
-    if (normId.includes("node_modules/scheduler")) return "framework-scheduler";
-    if (isOfType(normId, normSrc, /\/layout\.(tsx?|jsx?)$/)) {
-      const rel = normId.replace(normSrc, "");
-      if (rel === "/layout.tsx" || rel === "/layout.jsx") return "layouts/root";
-      return `layouts/${rel.replace(/\/layout\.(tsx?|jsx?)$/, "").replace(/^\//, "").replace(/\//g, "-") || "root"}`;
-    }
-    if (isOfType(normId, normSrc, /\/template\.(tsx?|jsx?)$/)) return "shared/template";
-    if (isOfType(normId, normSrc, /\/loading\.(tsx?|jsx?)$/)) return "shared/loading";
-    if (isOfType(normId, normSrc, /\/error\.(tsx?|jsx?)$/)) return "shared/error";
-    if (isPageModule(normId, normSrc)) {
-      const route = extractRoutePath(normId, normSrc);
-      if (route) return `pages/${routePathToChunkName(route)}`;
-    }
-    if (normId.includes("/components/")) {
-      const match = normId.replace(normSrc, "").match(/\/components\/([^/]+)\//);
-      return match ? `components/${match[1]}` : "components/shared";
-    }
-    if (normId.includes("/hooks/")) return "shared/hooks";
-    if (normId.includes("/lib/") || normId.includes("/utils/") || normId.includes("/helpers/")) return "shared/utils";
-    if (normId.includes("node_modules")) {
-      const parts = normId.split("node_modules/");
-      const pkg = parts[parts.length - 1];
-      const pkgName = pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("-").replace("@", "") : pkg.split("/")[0];
-      return getVendorChunkGroup(pkgName);
-    }
-    return void 0;
-  };
-}
-
-// src/plugin/hooks/config.ts
-async function handleConfig() {
-  const userConfig2 = await loadOlovaConfig();
-  const olovaConfig = getConfig();
-  console.log("\n  \x1B[1m\x1B[35m\u{1F52E} Olova Framework\x1B[0m");
-  if (Object.keys(userConfig2).length > 0) {
-    console.log("  \u2713 Loaded olova.config.ts");
-  }
-  const cssConfig = userConfig2.css || {};
-  const tailwindResult = cssConfig.tailwind !== false ? await detectTailwindConfig() : { detected: false };
-  const postcssResult = await detectPostCSSConfig();
-  const srcDir = path7.resolve(process.cwd(), "src");
-  const cssFiles = collectCSSFiles(srcDir);
-  logCSSStatus(tailwindResult, postcssResult, cssFiles.globalCSS);
-  let postcssConfig = void 0;
-  if (cssConfig.postcss !== false && !postcssResult.detected) {
-    postcssConfig = createDefaultPostCSSConfig(tailwindResult);
-  }
-  const config = {
-    build: {
-      outDir: olovaConfig.outDir,
-      chunkSizeWarningLimit: 500,
-      copyPublicDir: true,
-      rollupOptions: {
-        input: "virtual:olova-entry-client",
-        output: {
-          manualChunks: createManualChunks(path7.resolve(process.cwd(), "src")),
-          chunkFileNames: (chunkInfo) => {
-            const name = chunkInfo.name || "";
-            if (name.startsWith("framework-react-dom")) return "_olova/static/chunks/framework-[hash].js";
-            if (name.startsWith("framework-") || name.startsWith("vendor-")) return "_olova/static/chunks/[name]-[hash].js";
-            if (name.startsWith("pages/") || name.startsWith("pages-")) return "_olova/static/chunks/pages/[name]-[hash].js";
-            return "_olova/static/chunks/[name]-[hash].js";
-          },
-          entryFileNames: "_olova/static/chunks/main-[hash].js",
-          assetFileNames: (assetInfo) => {
-            const fileName = assetInfo.name || "";
-            if (fileName.endsWith(".css")) {
-              const baseName = fileName.split("/").pop()?.replace(".css", "") || "style";
-              return `_olova/static/css/${baseName}-[hash][extname]`;
-            }
-            return "_olova/static/media/[name]-[hash][extname]";
-          }
-        }
-      },
-      minify: "terser",
-      terserOptions: { compress: { drop_console: false, drop_debugger: true } },
-      sourcemap: false,
-      target: "esnext"
-    },
-    css: {
-      modules: cssConfig.modules !== false ? {
-        localsConvention: "camelCaseOnly",
-        generateScopedName: "[name]__[local]___[hash:base64:5]"
-      } : false,
-      postcss: postcssConfig,
-      devSourcemap: cssConfig.devSourceMap !== false
-    },
-    resolve: { alias: { "@": path7.resolve(process.cwd(), "src") } },
-    ...olovaConfig.vite
-  };
-  return config;
-}
-
-// src/plugin/hooks/server.ts
-import path11 from "path";
-import fs8 from "fs";
-
-// src/plugin/utils.ts
-import fs5 from "fs";
-import path8 from "path";
-function findPages(dir, baseDir, userConfig2, pages = [], context = { layouts: [] }) {
-  const files = fs5.readdirSync(dir);
-  const currentContext = {
-    layouts: [...context.layouts],
-    loading: context.loading,
-    error: context.error,
-    notFound: context.notFound,
-    template: context.template
-  };
-  for (const file of files) {
-    const fullPath = path8.join(dir, file).replace(/\\/g, "/");
-    if (file === "layout.tsx" || file === "layout.jsx") currentContext.layouts.push(fullPath);
-    if (file === "loading.tsx" || file === "loading.jsx") currentContext.loading = fullPath;
-    if (file === "error.tsx" || file === "error.jsx") currentContext.error = fullPath;
-    if (file === "not-found.tsx" || file === "not-found.jsx") currentContext.notFound = fullPath;
-    if (file === "template.tsx" || file === "template.jsx") currentContext.template = fullPath;
-  }
-  for (const file of files) {
-    const fullPath = path8.join(dir, file);
-    const isDirectory = fs5.statSync(fullPath).isDirectory();
-    if (isDirectory && file.startsWith("(") && file.endsWith(")")) {
-      findPages(fullPath, baseDir, userConfig2, pages, currentContext);
-      continue;
-    }
-    if (isDirectory && file !== "assets" && file !== "node_modules") {
-      findPages(fullPath, baseDir, userConfig2, pages, currentContext);
-    } else if (file === "page.tsx" || file === "page.jsx") {
-      let relativePath = path8.relative(baseDir, dir);
-      relativePath = relativePath.replace(/\([^)]+\)\/?/g, "");
-      let routePath = "/" + relativePath.replace(/\\/g, "/");
-      routePath = routePath.replace(/\/+/g, "/");
-      const isDynamic = routePath.includes("[") && routePath.includes("]");
-      if (isDynamic) {
-        routePath = routePath.replace(/\[\[\.{3}(.+?)\]\]/g, "*$1?").replace(/\[\.{3}(.+?)\]/g, "*$1").replace(/\[(.+?)\]/g, ":$1");
-      }
-      const finalPath = routePath === "/" ? "/" : routePath.replace(/\/$/, "");
-      const content = fs5.readFileSync(fullPath, "utf-8");
-      const hasStaticDirective = content.trimStart().startsWith('"use static"') || content.trimStart().startsWith("'use static'");
-      const isStatic = !isDynamic && (hasStaticDirective || !!userConfig2.ssg?.enabled);
-      pages.push({
-        path: finalPath,
-        componentPath: fullPath.replace(/\\/g, "/"),
-        layoutPaths: currentContext.layouts,
-        loadingPath: currentContext.loading,
-        errorPath: currentContext.error,
-        notFoundPath: currentContext.notFound,
-        templatePath: currentContext.template,
-        isStatic,
-        isDynamic
-      });
-    }
-  }
-  return pages;
-}
-
-// src/plugin/hooks/server/manifests.ts
-import fs7 from "fs";
-import path10 from "path";
-
-// src/plugin/cache.ts
-import fs6 from "fs";
-import path9 from "path";
-import crypto from "crypto";
-var OLOVA_DIR = ".olova";
-var CACHE_DIR = ".olova/cache";
-var PAGES_CACHE = ".olova/cache/pages";
-var DATA_CACHE = ".olova/cache/fetch-cache";
-var SERVER_DIR = ".olova/server";
-function generateFileHash(filePath) {
-  if (!fs6.existsSync(filePath)) return "";
-  const content = fs6.readFileSync(filePath, "utf-8");
-  return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
-}
-function generateBuildId() {
-  return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-}
-function initCacheDir(baseDir, mode = "production") {
-  const olovaDir = path9.join(baseDir, OLOVA_DIR);
-  const cacheDir = path9.join(baseDir, CACHE_DIR);
-  const pagesCache = path9.join(baseDir, PAGES_CACHE);
-  const dataCache = path9.join(baseDir, DATA_CACHE);
-  const serverDir = path9.join(baseDir, SERVER_DIR);
-  [olovaDir, cacheDir, pagesCache, dataCache, serverDir].forEach((dir) => {
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
-    }
-  });
-  const buildInfo = {
-    version: "1.0.0",
-    buildId: generateBuildId(),
-    startTime: (/* @__PURE__ */ new Date()).toISOString(),
-    mode,
-    nodeVersion: process.version,
-    olovaVersion: "2.0.48"
-  };
-  fs6.writeFileSync(path9.join(olovaDir, "build-info.json"), JSON.stringify(buildInfo, null, 2));
-  const packageInfo = {
-    name: "olova",
-    version: "2.0.48"
-  };
-  fs6.writeFileSync(path9.join(olovaDir, "package.json"), JSON.stringify(packageInfo, null, 2));
-  const serverFiles = {
-    version: 1,
-    config: {
-      env: {},
-      basePath: "",
-      trailingSlash: false
-    },
-    files: []
-  };
-  fs6.writeFileSync(path9.join(olovaDir, "required-server-files.json"), JSON.stringify(serverFiles, null, 2));
-}
-function getCachedPage(baseDir, pagePath) {
-  const cacheFile = path9.join(baseDir, PAGES_CACHE, `${pagePath.replace(/\//g, "_")}.json`);
-  if (fs6.existsSync(cacheFile)) {
-    try {
-      return JSON.parse(fs6.readFileSync(cacheFile, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-function setCachedPage(baseDir, pagePath, data, hash) {
-  const cacheFile = path9.join(baseDir, PAGES_CACHE, `${pagePath.replace(/\//g, "_") || "_root"}.json`);
-  const entry = {
-    hash,
-    timestamp: Date.now(),
-    data
-  };
-  fs6.writeFileSync(cacheFile, JSON.stringify(entry, null, 2));
-}
-function getCachedData(baseDir, pagePath) {
-  const cacheFile = path9.join(baseDir, DATA_CACHE, `${pagePath.replace(/\//g, "_") || "_root"}.json`);
-  if (fs6.existsSync(cacheFile)) {
-    try {
-      return JSON.parse(fs6.readFileSync(cacheFile, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-function setCachedData(baseDir, pagePath, data, hash) {
-  const cacheFile = path9.join(baseDir, DATA_CACHE, `${pagePath.replace(/\//g, "_") || "_root"}.json`);
-  const entry = {
-    hash,
-    timestamp: Date.now(),
-    data
-  };
-  fs6.writeFileSync(cacheFile, JSON.stringify(entry, null, 2));
-}
-function isCacheValid(cached, currentHash) {
-  if (!cached) return false;
-  return cached.hash === currentHash;
-}
-function generatePrerenderManifest(baseDir, pages) {
-  const manifest = {
-    version: "1.0",
-    routes: {},
-    dynamicRoutes: {}
-  };
-  for (const page of pages) {
-    manifest.routes[page.path] = {
-      dataRoute: page.isStatic ? `/data${page.path === "/" ? "/index" : page.path}.json` : null,
-      isStatic: page.isStatic,
-      srcHash: generateFileHash(page.componentPath)
-    };
-  }
-  const manifestPath = path9.join(baseDir, ".olova", "prerender-manifest.json");
-  fs6.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-  return manifest;
-}
-function clearCache(baseDir) {
-  const cacheDir = path9.join(baseDir, CACHE_DIR);
-  if (fs6.existsSync(cacheDir)) {
-    fs6.rmSync(cacheDir, { recursive: true, force: true });
-  }
-  initCacheDir(baseDir);
-}
-function getCacheAge(cached) {
-  return Math.floor((Date.now() - cached.timestamp) / 1e3);
-}
-
-// src/plugin/hooks/server/manifests.ts
-function setupServerManifests(baseDir, srcDir, pages) {
-  initCacheDir(baseDir, "development");
-  const routesManifest = {
-    version: 1,
-    basePath: "",
-    pages: pages.map((p) => ({
-      path: p.path,
-      componentPath: p.componentPath,
-      isStatic: p.isStatic,
-      isDynamic: p.isDynamic || false
-    })),
-    staticRoutes: pages.filter((p) => p.isStatic).map((p) => ({ path: p.path })),
-    dynamicRoutes: pages.filter((p) => p.isDynamic).map((p) => ({
-      path: p.path,
-      regex: p.path.replace(/:\w+/g, "[^/]+").replace(/\*/g, ".*")
-    }))
-  };
-  const olovaDir = path10.join(baseDir, ".olova");
-  fs7.writeFileSync(path10.join(olovaDir, "routes-manifest.json"), JSON.stringify(routesManifest, null, 2));
-  const appPathsManifest = {};
-  pages.forEach((p) => {
-    appPathsManifest[p.path] = [p.componentPath.replace(srcDir, "").replace(/\\/g, "/")];
-  });
-  fs7.writeFileSync(path10.join(olovaDir, "app-paths-manifest.json"), JSON.stringify(appPathsManifest, null, 2));
-  generatePrerenderManifest(baseDir, pages);
-}
-
-// src/plugin/hooks/server/logging.ts
-function logServerRoutes(pages) {
-  console.log("\n  \x1B[1m\x1B[36m\u26A1 Olova Dev Server\x1B[0m\n");
-  console.log("  \x1B[90m\u25B2 .olova directory created\x1B[0m\n");
-  console.log("  \x1B[1mRoutes:\x1B[0m");
-  console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  for (const page of pages) {
-    let icon = "\x1B[33m\u25CB\x1B[0m";
-    let type = "\x1B[33mCSR\x1B[0m";
-    if (page.isStatic) {
-      icon = "\x1B[32m\u25CF\x1B[0m";
-      type = "\x1B[32mSSG\x1B[0m";
-    }
-    console.log(`  \u2502 ${icon} ${page.path.padEnd(20)} ${type.padEnd(10)}\u2502`);
-  }
-  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  console.log("  \x1B[32m\u25CF\x1B[0m SSG (Static)  \x1B[33m\u25CB\x1B[0m CSR (Client)\n");
-}
-
-// src/plugin/html/head.ts
-function generateMetaTags(metadata, siteUrl = "", route = "", isCanonicalEnabled = true) {
-  let metaTags = "";
-  if (!metadata) return "";
-  const tags = {
-    description: metadata.description,
-    keywords: metadata.keywords,
-    author: metadata.author,
-    robots: metadata.robots
-  };
-  for (const [name, content] of Object.entries(tags)) {
-    if (content) metaTags += `    <meta name="${name}" content="${content}" />
-`;
-  }
-  if (metadata.canonical) {
-    metaTags += `    <link rel="canonical" href="${metadata.canonical}" />
-`;
-  } else if (isCanonicalEnabled && siteUrl && route) {
-    const canonicalUrl = `${siteUrl}${route === "/" ? "" : route}`;
-    metaTags += `    <link rel="canonical" href="${canonicalUrl}" />
-`;
-  }
-  if (metadata.openGraph) {
-    for (const [prop, content] of Object.entries(metadata.openGraph)) {
-      if (content) metaTags += `    <meta property="og:${prop}" content="${content}" />
-`;
-    }
-  }
-  if (metadata.twitter) {
-    for (const [name, content] of Object.entries(metadata.twitter)) {
-      if (content) metaTags += `    <meta name="twitter:${name}" content="${content}" />
-`;
-    }
-  }
-  return metaTags;
-}
-
-// src/hydration/serialization.ts
-function safeStringify(data) {
-  return JSON.stringify(data).replace(/[<>\/\u2028\u2029]/g, (char) => {
-    switch (char) {
-      case "<":
-        return "\\u003c";
-      case ">":
-        return "\\u003e";
-      case "/":
-        return "\\u002f";
-      case "\u2028":
-        return "\\u2028";
-      case "\u2029":
-        return "\\u2029";
-      default:
-        return char;
-    }
-  });
-}
-
-// src/hydration/generation.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 = {
-    id: "0",
-    html: "",
-    ready: true,
-    data: {
-      path: data.route,
-      params: data.params || {},
-      pattern: data.route === "/" ? "/" : data.route.replace(/\/[^/]+$/, "/:slug"),
-      isStatic: data.isStatic ?? true,
-      buildId
-    },
-    order: 0
-  };
-  scripts.push(`<script>_oF([0,"R",${safeStringify(routeChunk.data)}])</script>`);
-  const metadataChunk = {
-    id: "1",
-    html: "",
-    ready: true,
-    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 || {} }
-    },
-    order: 1
-  };
-  scripts.push(`<script>_oF([1,"M",${safeStringify(metadataChunk.data)}])</script>`);
-  const treeChunk = {
-    id: "2",
-    html: "",
-    ready: true,
-    data: { layout: "RootLayout", page: "Page", template: null, loading: null, error: null, notFound: null },
-    order: 2
-  };
-  scripts.push(`<script>_oF([2,"T",${safeStringify(treeChunk.data)}])</script>`);
-  const structuredData = {
-    id: "3",
-    html: "",
-    ready: true,
-    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" }
-    ],
-    order: 3
-  };
-  scripts.push(`<script>_oF([3,"D",${safeStringify(structuredData.data)}])</script>`);
-  const assetsChunk = {
-    id: "4",
-    html: "",
-    ready: true,
-    data: { chunks: data.chunks || [], styles: [], prefetch: (data.chunks || []).slice(0, 5) },
-    order: 4
-  };
-  scripts.push(`<script>_oF([4,"A",${safeStringify(assetsChunk.data)}])</script>`);
-  const hintsChunk = {
-    id: "5",
-    html: "",
-    ready: true,
-    data: { dnsPrefetch: ["fonts.googleapis.com"], preconnect: ["https://fonts.googleapis.com"], modulePreload: (data.chunks || []).slice(0, 3) },
-    order: 5
-  };
-  scripts.push(`<script>_oF([5,"H",${safeStringify(hintsChunk.data)}])</script>`);
-  const stateChunk = {
-    id: "6",
-    html: "",
-    ready: true,
-    data: { hydrated: false, streaming: false, ready: true, timestamp: Date.now(), version: "1.0.0", buildId },
-    order: 6
-  };
-  scripts.push(`<script>_oF([6,"S",${safeStringify(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=${safeStringify(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("/") })) }
-    ]
-  };
-  if (meta.schema) {
-    const schemas = Array.isArray(meta.schema) ? meta.schema : [meta.schema];
-    jsonLd["@graph"].push(...schemas);
-  }
-  return `<script type="application/ld+json">${JSON.stringify(jsonLd)}</script>`;
-}
-
-// src/plugin/html/hydration.ts
-function handleHtmlHydration(content, pageData, metadata, flightPayload, buildId) {
-  const hydrationData = {
-    route: flightPayload?.route || "/",
-    metadata: {
-      title: metadata?.title,
-      description: metadata?.description,
-      keywords: metadata?.keywords,
-      robots: metadata?.robots,
-      canonical: metadata?.canonical,
-      openGraph: metadata?.openGraph,
-      twitter: metadata?.twitter,
-      schema: metadata?.schema
-    },
-    params: flightPayload?.params || {},
-    chunks: [],
-    isStatic: !!pageData || !!content
-  };
-  const flightHydration = generateOlovaHydration(hydrationData, buildId);
-  const jsonLdScript = generateJsonLd(hydrationData);
-  const olovaData = {
-    props: { pageProps: pageData || {} },
-    page: flightPayload?.route || "/",
-    query: {},
-    buildId,
-    flight: flightPayload || null,
-    runtimeConfig: {},
-    isFallback: false,
-    gsp: !!pageData,
-    gssp: false
-  };
-  const olovaDataScript = `<script id="__OLOVA_DATA__" type="application/json">${JSON.stringify(olovaData).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/'/g, "\\u0027")}</script>`;
-  return { flightHydration, jsonLdScript, olovaDataScript };
-}
-
-// src/plugin/html/preload.ts
-function generatePreloadTags(manifest, routePath, scriptPath, cssLinks) {
-  let preloadTags = "";
-  if (manifest) {
-    const frameworkChunks = [manifest.framework.react, manifest.framework.reactDom, manifest.framework.scheduler].filter(Boolean);
-    for (const chunk of frameworkChunks) preloadTags += `    <link rel="modulepreload" href="/${chunk}" crossorigin />
-`;
-    const routeChunk = manifest.routes[routePath];
-    if (routeChunk) {
-      preloadTags += `    <link rel="modulepreload" href="/${routeChunk.chunk}" crossorigin />
-`;
-      for (const css of routeChunk.css) preloadTags += `    <link rel="preload" href="/${css}" as="style" />
-`;
-      for (const dep of routeChunk.dependencies) {
-        if (dep.priority === "critical" || dep.priority === "high") preloadTags += `    <link rel="modulepreload" href="/${dep.chunk}" crossorigin />
-`;
-      }
-    }
-  } else {
-    if (scriptPath) preloadTags += `    <link rel="modulepreload" href="${scriptPath}" />
-`;
-    cssLinks.forEach((href) => {
-      preloadTags += `    <link rel="preload" href="${href}" as="style" />
-`;
-    });
-  }
-  return preloadTags;
-}
-
-// src/plugin/html/prefetch.ts
-function generatePrefetchScript(manifest) {
-  if (!manifest) return "";
-  const manifestData = JSON.stringify({
-    routes: Object.fromEntries(Object.entries(manifest.routes).map(([path18, chunk]) => [path18, { chunk: chunk.chunk, css: chunk.css }])),
-    framework: manifest.framework
-  });
-  return `
-    <script type="module">
-    (function(){
-      const m=${manifestData};
-      const p=new Set(),q=[],MAX=3;let a=0;
-      function f(h){
-        if(p.has(h)||a>=MAX){if(!p.has(h))q.push(h);return}
-        p.add(h);a++;
-        const l=document.createElement('link');
-        l.rel='prefetch';l.href='/'+h;l.as=h.endsWith('.css')?'style':'script';
-        l.onload=l.onerror=()=>{a--;if(q.length)f(q.shift())};
-        document.head.appendChild(l);
-      }
-      function r(path){
-        const c=m.routes[path]||m.routes[path.replace(/\\/$/,'')];
-        if(c){f(c.chunk);c.css.forEach(f)}
-      }
-      const obs=new IntersectionObserver(e=>{
-        e.forEach(en=>{
-          if(en.isIntersecting){
-            const h=en.target.getAttribute('href');
-            if(h&&h.startsWith('/'))r(h);
-            obs.unobserve(en.target);
-          }
-        });
-      },{rootMargin:'50px'});
-      function init(){
-        document.querySelectorAll('a[href^="/"]').forEach(l=>{
-          if(!l.dataset.noPrefetch){
-            obs.observe(l);
-            let t;
-            l.addEventListener('mouseenter',()=>{t=setTimeout(()=>{
-              const h=l.getAttribute('href');if(h)r(h);
-            },100)});
-            l.addEventListener('mouseleave',()=>clearTimeout(t));
-          }
-        });
-      }
-      if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',init);
-      else init();
-      window.addEventListener('olova:navigate',init);
-    })();
-    </script>`;
-}
-
-// src/plugin/html/template.ts
-function generateHtmlTemplate(content, scriptPath, cssLinks = [], pageData, metadata, flightPayload, olovaConfig, preloadConfig) {
-  const buildId = Date.now().toString(36);
-  const siteUrl = olovaConfig?.siteUrl || "";
-  const route = flightPayload?.route || "/";
-  const metaTags = generateMetaTags(metadata, siteUrl, route, olovaConfig?.seo?.canonical !== false);
-  const { flightHydration, jsonLdScript, olovaDataScript } = handleHtmlHydration(content, pageData, metadata, flightPayload, buildId);
-  const preloadTags = generatePreloadTags(preloadConfig?.manifest, preloadConfig?.routePath || "/", scriptPath, cssLinks);
-  const cssLinkTags = cssLinks.length > 0 ? cssLinks.map((href) => `    <link rel="stylesheet" href="${href}" />`).join("\n") : "";
-  const prefetchScript = preloadConfig?.injectPrefetchScript ? generatePrefetchScript(preloadConfig.manifest) : "";
-  return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${metadata?.title || "Olova App"}</title>
-${metaTags}${preloadTags}${cssLinkTags ? cssLinkTags + "\n" : ""}    ${jsonLdScript}
-  </head>
-  <body>
-    <div id="root">${content}</div>
-    ${olovaDataScript}
-    ${flightHydration}
-    <script type="module" src="${scriptPath}"></script>${prefetchScript}
-  </body>
-</html>`;
-}
-
-// src/plugin/hooks/server/middleware.ts
-function createSsrMiddleware(server, srcDir, pageRoutes) {
-  return async (req, res, next) => {
-    const url = req.url || "";
-    const shouldSkip = url.includes(".") || url.startsWith("/@") || url.startsWith("/__") || url.startsWith("/node_modules") || url.includes("virtual:") || url.startsWith("/src") || req.method !== "GET";
-    if (shouldSkip) return next();
-    const urlPath = url.split("?")[0];
-    const normalizedPath = urlPath === "/" ? "/" : urlPath.replace(/\/$/, "");
-    const page = pageRoutes.get(normalizedPath);
-    const React = await import("react");
-    let content = "";
-    let pageMetadata;
-    if (page) {
-      try {
-        const pageModule = await server.ssrLoadModule(page.componentPath);
-        pageMetadata = pageModule.metadata || pageModule.default.metadata;
-        const layoutModules = await Promise.all(
-          (page.layoutPaths || []).map((lp) => server.ssrLoadModule(lp))
-        );
-        const Layouts = layoutModules.map((m) => m.default);
-        if (page.isStatic) {
-          const { renderToString } = await import("react-dom/server");
-          const Page = pageModule.default;
-          let pageContent = React.createElement(Page, null);
-          for (let i = Layouts.length - 1; i >= 0; i--) {
-            pageContent = React.createElement(Layouts[i], { children: pageContent });
-          }
-          content = renderToString(pageContent);
-          console.log(`  \x1B[32m\u25CF SSG\x1B[0m ${normalizedPath}`);
-        }
-      } catch (err) {
-        if (page.isStatic) console.error(`  \x1B[31m\u2717 SSG failed\x1B[0m ${normalizedPath}: ${err.message}`);
-      }
-    }
-    const html = generateHtmlTemplate(content, "/src/entry-client.tsx", [], void 0, pageMetadata);
-    res.setHeader("Content-Type", "text/html");
-    server.transformIndexHtml(url, html).then((transformedHtml) => res.end(transformedHtml)).catch(next);
-  };
-}
-
-// src/plugin/hooks/server.ts
-function handleConfigureServer(server) {
-  const baseDir = process.cwd();
-  const srcDir = path11.resolve(baseDir, "src");
-  const userConfig2 = getUserConfig();
-  const pages = findPages(srcDir, srcDir, userConfig2);
-  setupServerManifests(baseDir, srcDir, pages);
-  logServerRoutes(pages);
-  const pageRoutes = new Map(pages.map((p) => [p.path, p]));
-  server.middlewares.use(createSsrMiddleware(server, srcDir, pageRoutes));
-}
-function handleConfigurePreviewServer(server) {
-  server.middlewares.use((req, res, next) => {
-    const url = req.url?.split("?")[0];
-    if (!url || url === "/" || url.includes(".")) return next();
-    const config = getConfig();
-    const baseDir = process.cwd();
-    const outDir = path11.resolve(baseDir, config.outDir || ".olova/dist");
-    try {
-      const indexHtml = path11.join(outDir, url, "index.html");
-      if (fs8.existsSync(indexHtml)) {
-        req.url = url + "/index.html";
-        return next();
-      }
-      const fileHtml = path11.join(outDir, url + ".html");
-      if (fs8.existsSync(fileHtml)) {
-        req.url = url + ".html";
-        return next();
-      }
-    } catch (e) {
-    }
-    next();
-  });
-}
-
-// src/plugin/hooks/transform.ts
-import path12 from "path";
-
-// src/plugin/constants.ts
-var HTML_MINIFY_OPTIONS = {
-  collapseWhitespace: true,
-  removeComments: true,
-  removeRedundantAttributes: true,
-  removeScriptTypeAttributes: true,
-  removeStyleLinkTypeAttributes: true,
-  useShortDoctype: true,
-  minifyCSS: true,
-  minifyJS: true,
-  sortAttributes: true,
-  sortClassName: true
-};
-var ENTRY_CLIENT_CODE = `
-import React from 'react';
-import { createRoot, hydrateRoot } from 'react-dom/client';
-import { Router, HeadProvider } from 'olova/client';
-import { routes } from 'virtual:olova-routes';
-import Layout from '@/layout';
-
-// Global CSS imports (auto-detected from src directory)
-import '@/index.css';
-
-// Chunk manifest for route-based code splitting
-let chunkManifest = null;
-
-async function loadChunkManifest() {
-  try {
-    const response = await fetch('/_olova/chunks-manifest.json');
-    if (response.ok) {
-      chunkManifest = await response.json();
-      window.__OLOVA_CHUNK_MANIFEST__ = chunkManifest;
-      console.log('[Olova] Loaded chunk manifest:', Object.keys(chunkManifest.routes || {}).length, 'routes');
-    }
-  } catch (error) {
-    // Manifest may not exist in dev mode, that's fine
-    console.debug('[Olova] Chunk manifest not available (normal in dev mode)');
-  }
-}
-
-function getOlovaData() {
-  if (typeof document === 'undefined') return null;
-  try {
-    const script = document.getElementById('__OLOVA_DATA__');
-    if (!script) return null;
-    return JSON.parse(script.textContent || '{}');
-  } catch (error) {
-    console.error('[Olova] Failed to parse __OLOVA_DATA__:', error);
-    return null;
-  }
-}
-
-function getFlightPayload() {
-  try {
-    const olovaData = getOlovaData();
-    if (olovaData?.flight && olovaData.flight.v === 1) {
-      return olovaData.flight;
-    }
-    return null;
-  } catch (error) {
-    console.error('[Olova] Failed to parse Flight payload:', error);
-    return null;
-  }
-}
-
-function progressiveHydrate(rootElement, app, payload) {
-  try {
-    hydrateRoot(rootElement, app, {
-      onRecoverableError(error) {
-        console.warn('[Olova] Hydration mismatch:', error);
-      },
-    });
-    requestAnimationFrame(() => {
-      document.documentElement.classList.add('olova-hydrated');
-      window.dispatchEvent(new CustomEvent('olova:ready'));
-    });
-  } catch (error) {
-    console.error('[Olova] Hydration failed:', error);
-    createRoot(rootElement).render(app);
-  }
-}
-
-// Load chunk manifest early (non-blocking)
-loadChunkManifest();
-
-window.__OLOVA_ROUTES__ = routes;
-
-const App = () => React.createElement(
-  HeadProvider,
-  null,
-  React.createElement(
-    Layout,
-    null,
-    React.createElement(Router, { routes: routes })
-  )
-);
-
-const rootElement = document.getElementById('root');
-const flightPayload = getFlightPayload();
-const hasServerContent = rootElement.innerHTML.trim().length > 0;
-
-if (hasServerContent) {
-  console.log('[Olova] Hydrating');
-  progressiveHydrate(rootElement, React.createElement(App), flightPayload);
-} else {
-  console.log('[Olova] Client-side rendering');
-  createRoot(rootElement).render(React.createElement(App));
-  requestAnimationFrame(() => {
-    document.documentElement.classList.add('olova-hydrated');
-    window.dispatchEvent(new CustomEvent('olova:ready'));
-  });
-}
-
-if (import.meta.hot) {
-  import.meta.hot.accept();
-}
-`;
-
-// src/plugin/hooks/transform.ts
-var virtualModuleId = "virtual:olova-routes";
-var resolvedVirtualModuleId = "\0" + virtualModuleId;
-var virtualEntryId = "virtual:olova-entry-client";
-var resolvedVirtualEntryId = "\0" + virtualEntryId;
-function handleResolveId(id) {
-  if (id === virtualModuleId) return resolvedVirtualModuleId;
-  if (id === virtualEntryId || id === "/src/entry-client.tsx") return resolvedVirtualEntryId;
-  return null;
-}
-function handleLoad(id) {
-  if (id === resolvedVirtualEntryId) return ENTRY_CLIENT_CODE;
-  if (id === resolvedVirtualModuleId) {
-    const srcDir = path12.resolve(process.cwd(), "src");
-    const userConfig2 = getUserConfig();
-    const pages = findPages(srcDir, srcDir, userConfig2);
-    const routesCode = pages.map((p) => {
-      const importPath = p.componentPath.replace(/\\/g, "/");
-      const layouts = p.layoutPaths.map((lp) => `() => import('${lp.replace(/\\/g, "/")}')`).join(", ");
-      let extra = "";
-      if (p.loadingPath) extra += `, loading: () => import('${p.loadingPath.replace(/\\/g, "/")}')`;
-      if (p.errorPath) extra += `, error: () => import('${p.errorPath.replace(/\\/g, "/")}')`;
-      if (p.notFoundPath) extra += `, notFound: () => import('${p.notFoundPath.replace(/\\/g, "/")}')`;
-      if (p.templatePath) extra += `, template: () => import('${p.templatePath.replace(/\\/g, "/")}')`;
-      return `{ 
-    path: '${p.path}', 
-    component: () => import('${importPath}'), 
-    layouts: [${layouts}],
-    static: ${p.isStatic}, 
-    dynamic: ${p.isDynamic || false}${extra} 
-  }`;
-    }).join(",\n  ");
-    return `export const routes = [
-  ${routesCode}
-];`;
-  }
-  return null;
-}
-function handleTransform(code) {
-  if (code.includes('"use static"') || code.includes("'use static'")) {
-    return code.replace(/['"]use static['"];?/, "");
-  }
-  return null;
-}
-
-// src/plugin/hooks/bundle.ts
-import path17 from "path";
-
-// src/plugin/ssg/config.ts
-import fs9 from "fs";
-import path13 from "path";
-function discoverEntries(outDir) {
-  let jsEntry = "";
-  const cssEntries = getCSSForBuild(outDir);
-  const chunksDir = path13.join(outDir, "_olova", "static", "chunks");
-  if (fs9.existsSync(chunksDir)) {
-    const chunks = fs9.readdirSync(chunksDir);
-    for (const chunk of chunks) {
-      if (chunk.startsWith("main") && chunk.endsWith(".js")) {
-        jsEntry = "/_olova/static/chunks/" + chunk;
-        break;
-      }
-    }
-  }
-  return { jsEntry, cssEntries };
-}
-
-// src/plugin/ssg/seo.ts
-import fs10 from "fs";
-import path14 from "path";
-function generateSeoFiles(outDir, pages, siteUrl, seo) {
-  if (!siteUrl) return;
-  if (seo?.sitemap !== false) {
-    const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${pages.map((page) => `  <url>
-    <loc>${siteUrl}${page.path === "/" ? "" : page.path}</loc>
-    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
-    <changefreq>daily</changefreq>
-    <priority>${page.path === "/" ? "1.0" : "0.8"}</priority>
-  </url>`).join("\n")}
-</urlset>`;
-    fs10.writeFileSync(path14.join(outDir, "sitemap.xml"), sitemap);
-  }
-  if (seo?.robots !== false) {
-    let content = typeof seo?.robots === "object" && seo.robots.rules ? seo.robots.rules : `User-agent: *
-Allow: /
-
-Sitemap: ${siteUrl}/sitemap.xml`;
-    if (typeof seo?.robots === "object" && seo.robots.sitemaps) {
-      seo.robots.sitemaps.forEach((s) => {
-        content += `
-Sitemap: ${s}`;
-      });
-    }
-    fs10.writeFileSync(path14.join(outDir, "robots.txt"), content);
-  }
-}
-
-// src/plugin/ssg/renderer.ts
-import fs11 from "fs";
-import path15 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-import { build as viteBuild } from "vite";
-async function renderStaticPage(baseDir, srcDir, page) {
-  const tempSSRDir = path15.join(baseDir, ".olova/ssr");
-  if (!fs11.existsSync(tempSSRDir)) fs11.mkdirSync(tempSSRDir, { recursive: true });
-  const pkgPath = path15.join(tempSSRDir, "package.json");
-  if (!fs11.existsSync(pkgPath)) fs11.writeFileSync(pkgPath, JSON.stringify({ type: "module" }));
-  const layoutPath = fs11.existsSync(path15.join(srcDir, "layout.tsx")) ? path15.join(srcDir, "layout.tsx") : fs11.existsSync(path15.join(srcDir, "layout.jsx")) ? path15.join(srcDir, "layout.jsx") : null;
-  const layoutImport = layoutPath ? `import Layout from '${layoutPath.replace(/\\/g, "/")}';` : "";
-  const layoutUsage = layoutPath ? ["<Layout>", "</Layout>"] : ["<>", "</>"];
-  const tempEntry = path15.join(tempSSRDir, `entry-${Math.random().toString(36).substring(7)}.tsx`);
-  const content = `import React from 'react';
-import { renderToString } from 'react-dom/server';
-${layoutImport}
-import Page from '${page.componentPath.replace(/\\/g, "/")}';
-export default function render() { return renderToString(${layoutUsage[0]}<Page />${layoutUsage[1]}); }`;
-  fs11.writeFileSync(tempEntry, content);
-  try {
-    await viteBuild({
-      configFile: false,
-      root: baseDir,
-      build: { ssr: true, write: true, outDir: tempSSRDir, emptyOutDir: false, rollupOptions: { input: tempEntry, output: { format: "esm", entryFileNames: "[name].js" }, onwarn: (w, h) => {
-        if (w.code !== "MODULE_LEVEL_DIRECTIVE") h(w);
-      } } },
-      plugins: [{ name: "olova-ssr-transforms", transform: (c) => c.replace(/['"]use static['"];?/, "") }],
-      logLevel: "silent"
-    });
-    const builtPath = tempEntry.replace(".tsx", ".js");
-    if (fs11.existsSync(builtPath)) {
-      const mod = await import(pathToFileURL2(builtPath).href);
-      return { content: mod.default(), metadata: mod.metadata };
-    }
-    throw new Error("Built artifact not found");
-  } finally {
-    if (fs11.existsSync(tempEntry)) fs11.unlinkSync(tempEntry);
-    const builtPath = tempEntry.replace(".tsx", ".js");
-    if (fs11.existsSync(builtPath)) fs11.unlinkSync(builtPath);
-  }
-}
-
-// src/plugin/ssg/runner.ts
-import fs12 from "fs";
-import path16 from "path";
-async function runSSG(baseDir, pages, olovaConfig) {
-  initCacheDir(baseDir);
-  console.log("\n\u{1F4E6} Generating pages...");
-  const outDir = path16.resolve(baseDir, olovaConfig.outDir || ".olova/dist");
-  const srcDir = path16.resolve(baseDir, "src");
-  const { jsEntry, cssEntries } = discoverEntries(outDir);
-  const { minify } = await import("html-minifier-terser");
-  const srcInDist = path16.join(outDir, "src");
-  if (fs12.existsSync(srcInDist)) fs12.rmSync(srcInDist, { recursive: true, force: true });
-  if (!fs12.existsSync(outDir)) fs12.mkdirSync(outDir, { recursive: true });
-  fs12.writeFileSync(path16.join(outDir, "prerender-manifest.json"), JSON.stringify(generatePrerenderManifest(baseDir, pages), null, 2));
-  for (const page of pages) {
-    const startTime = Date.now();
-    const htmlPath = page.path === "/" ? path16.join(outDir, "index.html") : path16.join(outDir, page.path, "index.html");
-    if (page.path !== "/" && !fs12.existsSync(path16.dirname(htmlPath))) fs12.mkdirSync(path16.dirname(htmlPath), { recursive: true });
-    let content = "", metadata = void 0;
-    if (page.isStatic) {
-      try {
-        const result = await renderStaticPage(baseDir, srcDir, page);
-        content = result.content;
-        metadata = result.metadata;
-        console.log(`  \x1B[32m\u25CF SSG\x1B[0m ${page.path} \x1B[90m(${Date.now() - startTime}ms)\x1B[0m`);
-      } catch (err) {
-        console.error(`  \x1B[31m\u2717 SSG failed\x1B[0m ${page.path}: ${err.message}`);
-      }
-    }
-    const fullHtml = generateHtmlTemplate(content, jsEntry, cssEntries, void 0, metadata, { route: page.path, params: {}, v: 1 }, olovaConfig);
-    fs12.writeFileSync(htmlPath, await minify(fullHtml, HTML_MINIFY_OPTIONS));
-  }
-  const buildManifest = {
-    version: Date.now().toString(36),
-    buildTime: (/* @__PURE__ */ new Date()).toISOString(),
-    pages: pages.map((p) => ({ path: p.path, isStatic: p.isStatic })),
-    assets: { main: jsEntry, css: cssEntries }
-  };
-  fs12.writeFileSync(path16.join(outDir, "build-manifest.json"), JSON.stringify(buildManifest, null, 2));
-  generateSeoFiles(outDir, pages, olovaConfig?.siteUrl, olovaConfig?.seo);
-  console.log(`
-\u2705 Build complete!
-`);
-}
-
-// src/plugin/hooks/bundle/collection.ts
-function collectAssetsAndChunks(bundle, chunkCollector) {
-  const cssFiles = /* @__PURE__ */ new Map();
-  for (const [fileName, asset] of Object.entries(bundle)) {
-    if (asset.type === "asset" && fileName.endsWith(".css")) {
-      const name = asset.name || fileName;
-      cssFiles.set(name, fileName);
-    }
-    if (asset.type === "chunk") {
-      const chunk = asset;
-      const name = chunk.name || "";
-      if (["framework-react", "framework-react-dom", "framework-scheduler"].includes(name)) {
-        trackFrameworkChunk(chunkCollector, name, fileName);
-      }
-      if (name.startsWith("framework-") || name.startsWith("vendor-")) {
-        addSharedChunk(chunkCollector, fileName);
-        addToChunkGroup(chunkCollector, name.startsWith("framework-") ? "framework" : "vendor", fileName);
-      }
-      const categories = ["layouts", "components", "shared"];
-      for (const cat of categories) {
-        if (name.startsWith(`${cat}/`)) addToChunkGroup(chunkCollector, cat, fileName);
-      }
-    }
-  }
-  return cssFiles;
-}
-
-// src/plugin/hooks/bundle/mapping.ts
-function mapRoutesToChunks(pages, bundle, chunkCollector, cssFiles) {
-  for (const page of pages) {
-    const chunkName = `pages/${routePathToChunkName(page.path)}`;
-    for (const [fileName, chunk] of Object.entries(bundle)) {
-      if (chunk.type === "chunk" && chunk.name === chunkName) {
-        const dependencies = [];
-        if (chunkCollector.framework.react) dependencies.push({ chunk: chunkCollector.framework.react, priority: "critical" });
-        if (chunkCollector.framework.reactDom) dependencies.push({ chunk: chunkCollector.framework.reactDom, priority: "critical" });
-        const layoutChunks = chunkCollector.chunkGroups.get("layouts");
-        if (layoutChunks) {
-          for (const layoutChunk of layoutChunks) dependencies.push({ chunk: layoutChunk, priority: "high" });
-        }
-        const routeCss = [];
-        for (const [_, cssPath] of cssFiles) {
-          if (cssPath.includes("app") || cssPath.includes("index") || cssPath.includes("main")) routeCss.push(cssPath);
-        }
-        addRouteChunk(
-          chunkCollector,
-          page.path,
-          fileName,
-          (chunk.code || "").length,
-          page.isStatic || false,
-          page.isDynamic || false,
-          routeCss,
-          dependencies,
-          page.path === "/" ? "high" : "normal"
-        );
-        addToChunkGroup(chunkCollector, "pages", fileName);
-        break;
-      }
-    }
-  }
-}
-
-// src/plugin/hooks/bundle.ts
-function handleGenerateBundle(bundle, isBuild) {
-  for (const fileName of Object.keys(bundle)) {
-    if (fileName.startsWith("src/")) delete bundle[fileName];
-  }
-  if (!isBuild) return createChunkCollector();
-  const baseDir = process.cwd();
-  const srcDir = path17.resolve(baseDir, "src");
-  const userConfig2 = getUserConfig();
-  const pages = findPages(srcDir, srcDir, userConfig2);
-  const chunkCollector = createChunkCollector();
-  const cssFiles = collectAssetsAndChunks(bundle, chunkCollector);
-  mapRoutesToChunks(pages, bundle, chunkCollector, cssFiles);
-  return chunkCollector;
-}
-async function handleCloseBundle(isBuild, chunkCollector) {
-  if (!isBuild) return;
-  const baseDir = process.cwd();
-  const srcDir = path17.resolve(baseDir, "src");
-  const userConfig2 = getUserConfig();
-  const pages = findPages(srcDir, srcDir, userConfig2);
-  const olovaConfig = getConfig();
-  const manifest = generateChunkManifest(chunkCollector);
-  const outDir = path17.resolve(baseDir, olovaConfig.outDir || ".olova/dist");
-  writeChunkManifest(outDir, manifest);
-  await runSSG(baseDir, pages, olovaConfig);
-}
-
-// src/plugin/plugin.ts
-function olova() {
-  let isBuild = false;
-  let chunkCollector = createChunkCollector();
-  return {
-    name: "vite-plugin-olova",
-    config: () => handleConfig(),
-    configResolved(config) {
-      isBuild = config.command === "build";
-    },
-    configureServer: (server) => handleConfigureServer(server),
-    resolveId: (id) => handleResolveId(id),
-    load: (id) => handleLoad(id),
-    transform: (code) => handleTransform(code),
-    generateBundle(_, bundle) {
-      chunkCollector = handleGenerateBundle(bundle, isBuild);
-    },
-    configurePreviewServer: (server) => handleConfigurePreviewServer(server),
-    closeBundle: () => handleCloseBundle(isBuild, chunkCollector)
-  };
-}
-
-// src/plugin/index.ts
-var plugin_default = olova;
-export {
-  clearCache,
-  collectCSSFiles,
-  createDefaultPostCSSConfig,
-  createViteCSSConfig,
-  plugin_default as default,
-  detectPostCSSConfig,
-  detectTailwindConfig,
-  generateBuildId,
-  generateCSSImports,
-  generateCSSLinks,
-  generateFileHash,
-  generatePrerenderManifest,
-  getCSSForBuild,
-  getCacheAge,
-  getCachedData,
-  getCachedPage,
-  initCacheDir,
-  isCSSFile,
-  isCSSModule,
-  isCacheValid,
-  logCSSStatus,
-  olova,
-  setCachedData,
-  setCachedPage
-};
-//# sourceMappingURL=index.js.map